TL;DR. In mid-November, a viral post claimed Google had just released a free, nearly two-hour Harness engineering course. Tracing it back, the ~1-hour-35-minute video is a splice of two separate pieces:

  • The first 9 minutes: a short video titled “AI harness crash course,” published by Google Cloud Tech on October 22.
  • The remaining ~85 minutes: a livestream titled “Agent 102: Agent Evaluation + Self Evolving,” broadcast by presenter Annie Wang on her personal channel on October 14. The chapter titles in the post were rewritten; “Chief of Staff” and “7×24 unattended” do not appear in either transcript.
  • The originals focus on evaluation: Wang uses a dinner-booking agent to show that a self-improving loop follows the judge’s scores to decide where to go next. A judge that only looks at restaurant ratings can push the system in the wrong direction.
  • Both originals are embedded below, along with a mapping of the circulating version’s chapters to timestamps in the originals, and a half-hour viewing guide.

On the evening of November 19, Hux (@huxlab) posted in Chinese on X, saying Google had just released a complete, nearly two-hour Harness engineering course from which you could build a 7×24 self-evolving agent system from scratch. The post broke the course into four layers: first build the harness foundation, then do eval engineering, then get the loop running, and finally build a self-evolving graph system that automatically turns real failures into exam questions for the next round. The closing line: this practice of turning “looks right” into “verified, and self-improving” used to be top-tier teams’ best-kept secret. When I saw it, the post had 137,000 views.

I wanted to watch the course, so I had an agent trace the post back to its source. The original turned out to be two videos. The longer one is a livestream that had 2,755 views as of November 20.

Where Did This “Google 2-Hour Harness Course” Come From?

Hux’s post was drawing on a Spanish-language post by rob. (@robiartec) from November 18. The two posts share the same core claim: Google just released a free two-hour course, five chapters, worth more than a five-hundred-dollar class. “7×24 unattended,” “same model with dramatically different results,” and the four-layer architecture were added by Hux. Rob.’s post directly embedded a video running 1 hour 35 minutes 11 seconds, with five timestamps you could click to jump to specific sections. That video post accumulated 600,000 views. Someone in the comments linked to a YouTube video from Google Cloud Tech titled “AI harness crash course,” which runs only 9 minutes 27 seconds.

The lengths did not match, so I kept digging. By November 13, a YouTube video titled “Google Just Released a FREE 2-Hour Harness Engineering Masterclass” had already appeared, matching the same runtime as the video in rob.’s post. Its description listed the same five chapters and included the five-hundred-dollar line. The uploading channel had 7 subscribers. This is the earliest spliced version I found, though it may not be the original source.

Comparing transcripts, the video is composed of two parts. The first nine-plus minutes are from “AI harness crash course,” published by Google Cloud Tech on October 22, with Annie Wang, a Google Cloud software engineer, as presenter. The remaining ~85 minutes come from Wang’s own channel: a livestream titled “Agent 102: Agent Evaluation + Self Evolving” broadcast on October 14, originally 1 hour 25 minutes 53 seconds. It is part of her weekly agent-series live workshop, where she codes and explains simultaneously. During the session, an API quota error caused one evaluation segment to use results from a prior run. ADK optimize also took too long, so she switched to pre-prepared instructions for that demonstration.

Claim in the postSourceWhat the originals show
Google just released itBoth postsThe short video was published by Google Cloud Tech on October 22; the livestream was broadcast on Annie Wang’s personal channel on October 14; the earliest spliced version I found is dated November 13
Nearly 2-hour complete courseBoth postsA 9-minute 27-second short plus a 1-hour 25-minute 53-second livestream, totaling roughly 1 hour 35 minutes
Five chapters: build a harness from scratch, first agent, Chief of Staff evaluation, loop engineering, self-improving graph systemrob.; the November 13 YouTube description already listed theseChapter titles are rewritten; for where these five timestamps fall in the originals, see the next section
Define “good” using a Chief of Staff agent standardBoth posts (rob. uses it as a chapter title)Neither transcript contains “chief” or “staff”; the evaluation example in the livestream is booking dinner for five friends
A self-evolving graph system running 7×24 unattendedHuxThe demo shows an improvement loop connected via a router; when discussing production deployment, the presenter said that part was not included in that session’s hands-on work
Same model, different outer layer, outputs vary dramaticallyHuxThat phrasing does not appear in either transcript

One more detail worth noting: the word “harness” only appears in the first 9-minute short. In the remaining 85 minutes of livestream, covering agent evaluation and self-improvement, “harness” does not appear in the transcript once.

I also searched the Google Cloud Tech channel and went through the livestreams and courses tabs. No two-hour version.

Where to Find the Originals

The spliced version was uploaded by a third party, so I am embedding only the two originals here. Views will count toward the original channels.

Short video: AI harness crash course, 9 minutes 27 seconds, first published 2026-10-22 (source: Google Cloud Tech YouTube channel, presenter Annie Wang)

The short video walks through the four components of a harness using a “add a CSV export button” coding task. The description includes a link to the codelab. The video description lists fourteen chapters; I have consolidated them below:

TimestampContent
0:00What is an AI harness
0:49The loop: read file, modify, test, feed results back to the model
1:19The four parts of harness design
1:40Context and memory: session, state, long-term memory
3:37Tools and execution flow: Python functions, MCP, graph-based workflows
5:18Execution environment, prompt injection, and privacy
7:25Evaluation: deterministic checks, LLM judge, human review

Livestream: Agent 102: Agent Evaluation + Self Evolving, 1 hour 25 minutes 53 seconds, broadcast 2026-10-14 (source: Annie Wang YouTube channel)

The livestream description lists seven chapters:

TimestampChapter
0:00Evaluation overview
22:10Types of evaluation
33:42Implementing custom metrics
44:15The self-improvement logic
55:29ADK optimize and instruction tuning
1:07:19Building the automated loop
1:24:42Q&A and closing

If you arrived from that viral post, the five timestamps it listed correspond to roughly the following positions in the originals. The livestream in the spliced version starts about 9 minutes 24 seconds later than in the original. I estimated this by matching the same line of dialogue in both transcripts:

Circulating version labelOriginal positionWhat that segment actually covers
0:29 Harness engineering from scratchShort video 0:29What is an AI harness
11:08 Build your first agent rightLivestream 1:44The dinner-booking scenario and the three questions this loop is designed to answer
28:08 Chief of Staff agent for eval engineeringLivestream 18:44Two agents with identical results but different processes: why looking only at outcomes is not enough
1:00:13 Loop engineeringLivestream 50:49Starting to rewrite instructions with ADK optimize
1:23:19 A self-improving graph that never stopsLivestream 1:13:55Suggested direction for production deployment; presenter says this is not included in that session’s hands-on work

If you only have half an hour: watch the short video from the beginning (about 9 minutes), then in the livestream watch from 18:41 to around the 25-minute mark for the comparison between two agents and the trade-offs of ground-truth comparison versus LLM-as-a-judge. Then jump to 42:08 for about 3 minutes to see how the custom evaluator checks seat by seat. After that, go to 59:41 for the judge-swapping demo, and finally 1:07:25 to see the loop assembled.

What the Livestream Actually Teaches

The livestream uses a different task: an agent booking dinner for five friends. Marcos is vegetarian, Priya is allergic to nuts, Yuki needs to leave by a certain time, and Tom has transportation constraints. Wang opens by saying that picking a restaurant purely by its rating will not necessarily work for everyone, which is why you need an evaluator that accounts for each person’s constraints. She then lays out the three questions the whole session will answer: how do you know whether the agent achieved its goal? How does the agent improve automatically? How do you let the whole thing run on its own until it produces the right answer?

She introduces the built-in ADK evaluation types (starting at 20:57), then explains why she is writing a custom evaluator for this case, organizing evaluation approaches into three categories (starting at 42:08):

  • Ground-truth comparison: Write out the expected response in advance, even the expected sequence of tool calls, then measure how close the actual result comes. Easy to control, but requires a correct ground truth to begin with, and leaves little room for variation.
  • LLM-as-a-judge: No labeled answers required, well-suited for open-ended questions. She cautions that the judge itself can make mistakes, and its scores may drift over time. This approach is introduced but not implemented in the session.
  • Custom evaluator: The hands-on implementation uses deterministic code logic, checking seat by seat whether each person can eat at that restaurant, then producing a score.

She also addresses why looking only at outcomes is not enough (starting at 18:41). Two agents both complete the booking: Agent A checked everyone’s calendars to confirm availability, then verified the restaurant’s hours before booking. Agent B skipped the calendar entirely, guessed the time, and happened to guess correctly. The final result looks identical. Once Agent B is deployed on a different task, it may fail, because its process was never measured.

When You Pick the Wrong Judge, Where Does a Self-Improving Loop Go?

After setting up the evaluation, Wang connects it with the improvement logic into a full loop (starting at 1:07:25). The booking agent runs first, the judge scores its output using the custom metrics, and then a router decides what happens next. If the score falls short, the output goes to a proposer, which uses ADK optimize to rewrite the agent’s instructions. The updated instructions are stored in the shared workflow state, so the agent reads the new instructions on the next iteration. Only when the score clears the threshold does the loop exit. She notes that ADK optimize takes roughly eight to ten minutes per run and tries around thirty candidate instructions, so she uses pre-prepared instructions for the live demonstration.

Starting at 59:41, she swaps in a deliberately flawed instruction set, then swaps in a judge that only scores the restaurant itself. Her conclusion: a judge that only asks “is the restaurant good?” is not a good judge for this system. Choosing the wrong judge for a self-improving system matters enormously, because a wrong judge can send the entire system in the wrong direction. She also notes this is a brief illustration and the demo does not run to completion due to time.

This is how I read the core point of the whole session. The loop itself only does “run again.” Where it goes is determined by the judge. If the judge watches the wrong thing, the more diligently the loop runs, the further it drifts.

The post’s phrase about “automatically turning real failures into exam questions for the next round” does have a source, near the end of the livestream (starting at 1:13:57). She explains that if you deploy on Google Cloud, you can enable a BigQuery plugin to log every user message and agent response as a data table, re-score them with custom metrics, and feed any that fail into training data for the next rewriting pass. She frames this as “one direction you could go,” and says upfront that the session’s hands-on portion does not cover production deployment. “7×24 unattended” does not appear in either transcript.

Closing the livestream, she says she especially likes the evaluation part: everyone is building agents now, and how reliable and how good those systems actually are is both an interesting and an important question.

Four-panel comic: When You Pick the Wrong Judge, Where Does a Self-Improving Loop Go? An agent booking dinner for five friends. Marcos is vegetarian, Priya is allergic to nuts; Picking a restaurant purely by its rating will not necessarily work for everyone; If the score falls short, the output goes to a proposer, which uses ADK optimize to rewrite the agent's instructions. Only when the score clears the threshold does the loop exit. Annie Wang: a wrong judge can send the entire system in the wrong direction. If the judge watches the wrong thing, the more diligently the loop runs, the further it drifts. The stamp is the author's reading.

A Similar Situation in My Own Scoring System

I have run into something like this in my own systems. The shape was less obvious.

I built a translation quality evaluation framework called TQEF. After adding three industry glossaries and a set of business-register rules, the scores on the next round rose from 4.69 to 4.97 out of 5. Later, writing “When the Harness Changes, the Criteria Need Recalibrating Too,” I noted: that result reflects this evaluator’s judgment on those 29 test sentences at that moment. The evaluator itself had not yet been cross-validated, so the score could not serve as proof that the glossaries were working. The scores were going up. The judge had not been verified yet.

This month, while writing “The Prerequisite for 3,000 PRs in a Month,” I re-categorized 74 correction records and found three checks I thought were gatekeeping something that were actually validating the wrong version. For example: when a source sentence was revised, only one language’s translation was re-run. The other two languages kept the old translation, but the records showed them as updated. The check was still there. The log said “updated.” It was checking the wrong version. All three remain on the fix list.

Annie Wang’s restaurant-rating-only judge is at least obviously wrong. The version I encountered had rising scores and logs showing “updated.” Everything looked fine.

How Did This Post Spread?

Tracing the journey: on November 13, a spliced video appeared on YouTube with five chapters already written into the description; it had 269 views at the time of my check. On November 18, rob. embedded a video of the same length directly in a Spanish-language post, which accumulated 600,000 views. On November 19, Hux’s Chinese-language post drew on rob.’s, reaching 137,000 views. The chapter content traveled from an English-language YouTube description through Spanish to a Chinese-language four-layer architecture.

My reading: this is also a loop. At each turn, the only thing being judged is “does it get attention?” That judge does not check whether the chapters match the originals. The earliest I found the chapter titles was in the November 13 description; I could not locate an earlier source, nor can I confirm whether anyone who reshared the video had actually watched it. What I can confirm is that opening the original videos immediately shows the chapter labels do not align.

Last month I examined another viral post: one that opened with AGI panic and ended by pointing you to a harness guide (“An AGI Panic Post That Ends by Pointing You to an Engineering Guide”). This one has a different shape. No panic. Just good news. The fact-checking steps are the same either way: find the originals, check the dates, check the runtime, check the chapters.

Start by Asking What the Judge Is Watching

Both originals are embedded above, free to watch. If time is short, follow the half-hour viewing guide above.

The post itself says that without testing, evaluation, feedback, and automated iteration, you do not have a closed engineering loop. I ran that check myself. The most time-consuming step was opening the originals and verifying the timestamps.

The next time I see “a major company just released a free course,” I will start by looking for the original channel, date, and runtime. And before adding a self-improving loop to any agent, I will ask first: what is its judge actually watching?

For more writing on AI and human-AI collaboration: Intelligence and Order. How to set up an external judge, and why having multiple AI models review each other still falls short, is covered in “Before You Ask AI to Do Bigger Things, Build the Error-Catching Infrastructure First.”


Frequently Asked Questions

Q: Did Google actually release a free two-hour Harness engineering course?

Based on the original videos found on November 20, 2026, the circulating ~1-hour-35-minute video is a splice of two segments: a 9-minute 27-second short titled “AI harness crash course,” published by Google Cloud Tech on October 22, and a livestream titled “Agent 102: Agent Evaluation + Self Evolving” (1 hour 25 minutes 53 seconds) broadcast by presenter Annie Wang on her personal channel on October 14. Both are free to watch, and the presenter is a Google Cloud software engineer. However, searching the Google Cloud Tech channel’s videos, livestreams, and courses tab turned up no two-hour version.

Q: What do the two original videos cover?

The short video introduces the four components of an AI harness: context and memory, tools and execution flow, execution environment and security/privacy, and evaluation. The livestream uses an agent booking dinner for five friends to introduce three evaluation approaches (comparison against ground truth, LLM-as-a-judge, and custom evaluators), with hands-on demos of ground-truth comparison and a custom evaluator. It then uses ADK optimize to rewrite the agent’s instructions, and finally connects evaluation and rewriting into a loop using an ADK workflow router.

Q: Why does picking the wrong judge make a self-improving agent worse?

The loop uses the judge’s scores to decide whether to iterate again and in which direction. Annie Wang explains in the livestream that judging solely by a restaurant’s overall rating will not necessarily find a place that works for everyone, making such a judge a poor fit for this system. Pick the wrong judge, and the system may drift in entirely the wrong direction. She also cautions that when an LLM serves as the judge, the judge itself can make mistakes and its scores may drift over time.

Fact-Checking Method

The fact-checking in this article was conducted by my agent tracing the post back through its sources, with me verifying the results. A separate agent that was not involved in drafting then reopened the original videos and the post independently to re-check each claim. Titles, dates, runtimes, chapters, and view counts reflect what was visible on X and YouTube on November 20, 2026; all dates and times are Taiwan Standard Time. Transcripts for the livestream and the spliced version are YouTube auto-captions. The short video uses channel-uploaded captions. “Cannot be found” means a search of the transcript returned no result, though auto-caption mishearing cannot be ruled out.

References