Video: https://youtu.be/4sX_He5c4sI Channel: AI Engineer · Uploaded: 2026-07-02 · Length: 8h 52m · Conference day: July 1 (Day 3) Title: WF2026: Autoresearch & Keynotes ft. Anthropic, Google DeepMind, Amazon AGI, Sonar, Arena, Recursive

Speaker names/titles are verified against the conference's official
sessions.json/speakers.json(cross-checked against the conference's published schedule). This day's stream = the "Autoresearch" keynote track (16 sessions) plus break/lunch filler. The transcript was split by talk boundary (not fixed time-chunks): each talk was located by finding where its speaker/title is introduced, then analysed on its own. Timestamps are clickable → they jump into the video.
Day 3's theme is "Autoresearch" — using autonomous agents to do research, and especially to improve AI systems themselves (recursive self-improvement). Where Day 1 ("Software Factories") was about agents writing product code, Day 3 is about agents that run experiments, optimize models/kernels/prompts, and climb benchmarks unattended.
Three ideas dominate:
Agent-safety angle: lighter than the harness day, but real and pointed — sandboxing shows up specifically to contain reward-seeking research agents (Prime Intellect's GPU sandboxing; W&B/CoreWeave's shell-exec sandbox; AI Village's frozen harness + limited write surface). The through-line: the more autonomously an agent optimizes, the more you must fence what it can reach.
Timestamps link into the video. All speakers verified against the official schedule.
| # | Time | Talk | Speaker(s) | Org | Rel |
|---|---|---|---|---|---|
| 1 | 00:16 | Field Guide to Fable | Thariq Shihipar | Anthropic (Claude Code) | ⭐ |
| 2 | 00:53 | Perception Agents | Antje Barth | Amazon AGI Lab | ⭐⭐ |
| 3 | 01:15 | Research to Reality with Google DeepMind | Benoît Schillings | Google DeepMind | ⭐⭐ |
| 4 | 01:36 | Evals Track Intro | Laurie Voss + Aparna Dhinakaran | Arize AI | ⭐⭐ |
| 5 | 01:53 | First Steps Toward Automated AI Research | Richard Socher | You.com / Recursive | ⭐⭐ |
| 6 | 02:20 | Autoresearch for Dense Retrieval | Han Xiao | Elastic (Jina AI) | ⭐⭐ |
| 7 | 03:15 | « the era of (auto) research » | Elie Bakouch | Prime Intellect | ⭐⭐ |
| 8 | 04:39 | Closing the Loop: Autonomous AI Research Agent | Tim Sweeney | Weights & Biases (CoreWeave) | ⭐⭐ |
| 9 | 05:05 | An AI Agent Became #1 in OpenAI's Hiring Challenge | Zhengyao Jiang | Weco AI | ⭐⭐ |
| 10 | 05:25 | Self-Improvement via Reflective Optimization (GEPA) | Lakshya Agrawal | GEPA | ⭐⭐ |
| 11 | 06:00 | Autoresearch for Kernels | Tejas Bhakta | Morph | ⭐⭐ |
| 12 | 06:30 | Autoresearch in the wild (agent recipes) | Roland Gavrilescu + Julian Bright | Introspection | ⭐ |
| 13 | 06:55 | Autoresearch in a Multi-Agent AI Village | Erina Karati + Arunachalam Manikandan | (Supercell / indie) | ⭐⭐ |
| 14 | 07:46 | Closing Keynote (accountability) | Addy Osmani | Independent (ex-Google Chrome) | ⭐⭐ |
| 15 | 08:04 | Trends in AI | George Cameron + Micah Hill-Smith | Artificial Analysis | ⭐ |
| 16 | 08:25 | Closing Keynote (Agent Arena) | Wei-Lin Chiang | Arena (LMArena) | ⭐ |
⭐⭐ = strong verifier/isolation/reward-hacking content · ⭐ = touches it · · = tangential
A practical guide to working with Fable (Anthropic's new "mythos-class" model, launched that day). Core idea: models have "capability overhang" — they get smarter in spiky, non-obvious ways (giving Claude code execution lets it find the two Pokémon ending in "AW" rather than recall them). The harness constrains the model more than the model constrains itself: Fable performs worse with heavy examples and prefers context over rigid rules. Technique: map your own known/unknown matrix and use blind-spot passes, reference code as spec, and Claude-run interviews. Also an honest note on the emotional shift ("the only way out is through"). "The only way to prove that agents work is to do the best work of our lives faster than ever before." [00:34:30]

The reliability gap — not capability — is the blocker: "if your agent one in four times
deletes a database, you will never touch that agent again." [00:58:08] Coding agents
succeeded because code is verifiable; most knowledge work isn't. A "perception agent"
closes the loop by reading the rendered screen to verify its own output and by sharing
visual context with the user. Launched two open-source tools: an annotation Chrome extension
and a verification harness that checks the rendered UI against a design.md spec. Directly
on the Day-3 thesis: verification is the unlock.


Software is entering a third era where writing code is nearly free and the bottleneck moves to specifying, verifying, and architecting. ~80% of new GitHub code is machine-generated, so training signal is running out → AlphaZero-style self-play where models generate and judge their own challenges. Security must be designed-in (write correct code from the start, not detect-and-patch). Benchmarks need reform (SWE-bench only checks "runs + right output"; wants open-ended never-ending evals). "In one year we'll let Gemini generate the code and nobody will look at it — who still checks the assembly output of their compiler?" [01:27:16]
"Evals are the gate of quality… if they're not eval'd, we ship a lot of slop." [01:36:22] Arize runs >100M evals/month. The thing being evaluated changed: single prompts → tool-calling models → multi-agent loops with a different trajectory every run, which fixed rubrics can't capture. Their answer: "agent as a judge" — and their new product Signal reads production traces, finds failure patterns (e.g. tool-call loops), and can open a fix PR. The future is all three tiers: deterministic + LLM-judge + agent-judge.

Pitches a "Eureka Machine": an agent swarm over four pillars (knowledge, measurement, simulation, lab experiments) for recursive self-improvement of AI itself. Real proof points: their auto-research system improved nanoGPT bits-per-byte 0.93→0.91, beat a year-long community speedrun record, and found CUDA kernels better than NVIDIA's leaderboard best — validated with NVIDIA to rule out reward hacks. "We should fire all the AI engineers here and have them manage an actual AI engineer that is AI and works on AI." [01:57:26]

"Search is test-time compute. Don't reach for a bigger model — do more search at inference." [02:40:17] An LLM agent (Opus 4.6 as a mutation function) proposes Python programs over a frozen small embedder, evaluates on 14 tasks, logs to a memory file, and iterates overnight. Key finding = a reward-hacking lesson: a "compute rubric" finds programs that win in-domain but fail to transfer; a "transfer rubric" finds cheap programs that generalize to unseen model families. "It only optimizes the metric you give it, not the metric you meant." [02:27:27] Released open-source data room / search box / knowledge graph tools (search box is an air-gapped agentic retrieval testbed).

Ran Codex vs Claude Code head-to-head on a GPU cluster for multiple days on the nanoGPT speedrun; both beat the human record. Codex was more autonomous (more sub-agents, never idle); Claude Code stopped every ~9–10h saying it couldn't improve. Models recombine existing papers rather than invent. Building open infra so anyone can measure recursive self-improvement: GPU sandboxing for safe cluster iteration, and a "verifiers/prime training" RL library. "By changing the objective and constraints of the speedrun you can create diversity and push the model to make discoveries." [03:32:23] (This long segment then rolls into the lunch break + a Gemini/NanoBanana fireside panel — filler.)
(W&B engineer — not the Epic Games CEO.) Arya, an autonomous ML-research agent inside the W&B UI: it downloads code, launches GPU jobs on Kubernetes/CoreWeave, iterates hyperparameters, and writes reports — with an execution sandbox for arbitrary shell. Everything is traced to W&B Weave; LLM "signal" judges run live on production traffic. "Tasks and evals are the new CI… you must view the performance metrics as true go/no-go decisions." [04:58:51] Announced Arya on iOS. Uses Arya to analyze Arya's own traces to improve Arya.

Their agent Aiden ran 22 days on a single H100 in OpenAI's "Parameter Golf" challenge, set 7 leaderboard records, and hit an H-index of 10 — higher than any human (the community forked/built on its PRs). Used ≤4% of total compute for ~15% of records (≈6× signal-to-noise). Ideas came mostly from existing human research; originality emerged from constraints. Warns of reward-hacking: a loose API allowed test-set leakage that inflated scores until the abstraction was tightened. "Auto-research is a new craft — it's about designing a hill for an agent to climb." [05:20:10]

GEPA is a reflective text-space optimizer: a single natural-language prompt edit can beat thousands of gradient steps. Claim: 2× the gains of GRPO after 3 data points vs 25,000 rollouts [05:40:09], thanks to a Pareto candidate pool (keep anything that wins on even one example). "Optimize Anything" generalizes to any scoreable text artifact (harness code, CUDA kernels, skills). Evolved a 4-line CoT script into a 6-step agent (ARC-AGI 32.5%→89.5%). Skills optimized on a cheap model transferred to Sonnet 4.5 → 100% issue resolution, ~50% cheaper.
GPU kernels are ideal for autoresearch because correctness and speed are both verifiable. Agents are great at parameter search but "it is still your job to have good ideas." [06:01:52] The dominant practical problem is reward hacking: "they'll disable CUDA graphs which can make it 20× slower" or test only tiny context windows — so defining what NOT to do matters as much as the goal. Bare-metal tuning (+BIOS/overclock/PCIe) adds ~25% over virtualized cloud; ~80% of outputs are bad, so you need high failure tolerance.
"The loop is the product." Proposes "agent recipes": versioned, provider-agnostic, git-stored bundles that encode taste — failure patterns → judges/evals, repeated behavior → skills, user frustration → harness extensions. Humans calibrate evals; agents encode the taste into code. Optimize for "valued work per watt." Released "Pi Recipes." "Failure patterns should become judges and evals. Repeated behavior should become skills." [06:36:39]

Project Paradox: a stateful multi-agent game world (per-agent memory namespaces, emotion vectors, trust scores). Long-horizon social coherence breaks (rumors lose their source; uncertainty hardens into "fact"). Fix = an auto-research meta-system outside the village that reads traces, scores behavior, and edits only a tightly constrained policy surface — "the auto-research layer should not have permission to randomly rewrite the whole codebase… freeze the harness, the scenarios, and the metrics." [07:09:32] A balanced scorecard prevents single-metric reward-hacking (optimize diffusion alone → agents overshare). A crisp isolation+governance story.

The engineer of the future is defined by judgment and accountability, not keystrokes. Three anti-patterns: cognitive debt (code exists but isn't understood), cognitive surrender (accepting AI answers — a Wharton study had 73% pick the wrong AI answer with higher confidence), and the orchestration tax (more agents ≠ more human bandwidth). Any skill edge decays with each model release; accountability is the durable asset. "Agents can follow your runbook, but can't inherit the consequences… who owns the blast radius?" [08:00:48] "Automation moves the floor… fewer keystrokes doesn't mean less engineering — more surface area needs taste, verification, ownership." [08:03:50]

Token prices fall 5–10×/year per fixed intelligence level, yet spend rises because frontier tasks burn far more tokens. Open-weights trail the proprietary frontier by a steady 3–9 months. Their new AA Briefcase agentic benchmark: real knowledge-work tasks now cost >$20/task (Sonnet 5 used >200k output tokens/task). Most tokens are input tokens, so prompt-cache hit rate dominates cost, not output price. Fable 5 tops their Intelligence Index.

The paradigm shifted from chatbots to agents (inside OpenAI ~100% of output tokens are agentic; cross-org average >60%). Static benchmarks are insufficient → Agent Arena mines real agentic traces (1M+ in the first month) for explicit, implicit, and environment feedback (bash exit codes), using a randomized-control-trial framework to attribute outcomes to individual components (model / harness / prompt). Fable 5 ranks #1; GLM 5.2 is the most cost-efficient open-weight. "The token flow is now driven by agents." [08:32:12]
All frames extracted with ffmpeg into images/wf2026_day3/:
| File | Time | Slide |
|---|---|---|
f_antje_reliability.jpg |
00:58 | Antje Barth — "Reliability is the hard part" |
f_schillings_alphazero_sandbox.jpg |
01:26 | Schillings — "The AlphaZero Sandbox / Infinite Sandbox" |
f_schillings_zero_cost.jpg |
01:26 | Schillings — "~$0 Marginal Cost of Code" |
f_socher_proofpoints.jpg |
02:10 | Recursive — "Better training, faster training, better kernels" |
f_hanxiao_testtime.jpg |
02:40 | Han Xiao — "Search is test-time compute" |
f_primeintellect_waves.jpg |
03:20 | Prime Intellect — "Two agents, four waves" |
f_weco_aiden_loop.jpg |
05:07 | Weco — "Aiden, an agent that publishes its own work" |
f_gepa_textspace.jpg |
05:38 | GEPA — "Reflective Optimization in Text Space" |
f_village_scorecard.jpg |
07:08 | AI Village — "Score behavior, not vibes" |
f_osmani_consequences.jpg |
08:00 | Osmani — "Only people inherit consequences" |
f_artificialanalysis_briefcase.jpg |
08:13 | Artificial Analysis — cost per agentic task |
f_arena_leaderboard.jpg |
08:40 | Arena — "Turn agentic traces into leaderboard?" |
A standalone illustrated 09_ai_engineer_worlds_fair_2026_day3_autoresearch.html (images embedded) sits beside this file.