Google for Developers · Published 2026-09-01

Koray Kavukcuoglu on frontier models, coding agents, and building AGI

privateReview: unreviewedConfidence: high
frontierAGIgeminideepmindagentssoftware-engineeringcoding-agentsagentic-rlclosed-loop-environmentsfrontier-modelsfull-stack-ai
Open on YouTube ↗

Summary

Overview

  • Speaker: Logan Kilpatrick and Koray Kavukcuoglu
  • Channel: Google for Developers
  • Main topic: Frontier AI models, coding agents, and building AGI at Google DeepMind
  • Purpose: To provide deep insights into Google DeepMind's research philosophy, model iteration speed, architectural innovations, and the path toward AGI. Logan Kilpatrick and Koray Kavukcuoglu discuss the rapid progress of Gemini models (3.5, 3.6, 3.7), the evolution from models to agentic AI systems, coding and software engineering as foundational testbeds for AGI, the history of deep learning research at DeepMind, and Google's unique resources and long-term commitment to building safe and generally intelligent AI systems.

Topic Map

Gemini Model Progression and Reception

  • Explanation: Discussion on the rapid rollout and positive reception of Gemini 2.5, 3.6, and 3.7 over a three-week period.
  • Key claims:
    • Rapid iteration cycles have yielded overwhelmingly positive reception.
    • Architectural innovations have driven recent capability leaps.
  • Examples:
    • Releasing 2.5 at IO, followed quickly by 3.6 and 3.7.
  • Terminology:
    • Gemini
    • architecture
    • pre-training
  • Why it matters: Demonstrates accelerating capability velocity in frontier AI development.

Software Engineering as the Root Domain for AGI

  • Explanation: Explaining why software engineering is the most critical domain for AI systems because code touches every aspect of tool use and agentic workflows.
  • Key claims:
    • Software engineering is the most critical domain and environment for AI success.
    • Coding requires rigorous tooling use, planning, and long-horizon execution.
  • Examples:
    • Models transitioning from simple text generation to coding agents that write, debug, and execute code.
  • Terminology:
    • software engineering
    • agent
    • codebase
    • execution
  • Why it matters: Mastering software engineering unlocks broader agentic capabilities across scientific and general domains.

DeepMind History: From AlphaGo to Frontier LLMs

  • Explanation: Reflecting on DeepMind's history of focus projects like AlphaGo, AlphaZero, and AlphaFold, and how those lessons carry over to Gemini and AGI research.
  • Key claims:
    • Focus projects like AlphaGo and AlphaFold proved that reinforcement learning and deep learning could solve hard problems at scale.
    • Building AGI requires continuous exploration, rigorous evaluation, and diverse research teams.
  • Examples:
    • AlphaGo as the first major proof point of combining deep learning and reinforcement learning.
  • Terminology:
    • AlphaGo
    • AlphaZero
    • AlphaFold
    • reinforcement learning
  • Why it matters: Connects foundational reinforcement learning breakthroughs to modern LLM agent architectures.

Google's DNA and Long-Term AGI Ambition

  • Explanation: Examining Google's historical investments in frontier technologies like AI chips and quantum computing, and why Google is uniquely positioned to build AGI.
  • Key claims:
    • Google has a multi-decade history of investing in long-term, high-impact scientific endeavors.
    • Building AGI requires the full stack of infrastructure, compute, and consumer reach.
  • Examples:
    • Google investing in TPU chips and AI research 15 years ago before AI was mainstream.
  • Terminology:
    • TPU
    • frontier
    • full stack
    • compute
  • Why it matters: Explains the infrastructural and organizational advantages behind DeepMind's research engine.

Key Points

Shift from models to agents

  • Explanation: AI systems are moving from passive text-in/text-out models to active agents capable of using tools and executing complex multi-step workflows.
  • Evidence: Discussion on software engineering and agentic workflows.
  • Practical implication: Developers must design applications expecting AI to act autonomously with tools.

The importance of the frontier

  • Explanation: There is no substitute for pushing the frontier of model capability; current performance is a stepping stone to AGI.
  • Evidence: Koray's emphasis on 'nothing other than being at the frontier is important'.
  • Practical implication: Organizations must continuously invest in pushing capability boundaries rather than stopping at incremental product wrappers.

Combining deep learning and reinforcement learning

  • Explanation: The recipe for intelligence relies on pairing foundational deep learning representations with reinforcement learning and exploration.
  • Evidence: Historical parallels to AlphaGo, AlphaZero, and AlphaFold.
  • Practical implication: RL and agentic feedback loops are critical for post-training improvement.

Frameworks, Models & Processes

The Frontier Pursuit Framework

  • How it works: Continuous iterative capability expansion through parallel research tracks, combining architectural innovation with large-scale pre-training and agentic reinforcement learning.
  • Components:
    • Architectural innovation
    • Large-scale pre-training
    • Agentic reinforcement learning
    • Ecosystem integration
  • When to use: When building and scaling frontier AI systems toward general intelligence.

Examples & Case Studies

Development of AlphaGo and AlphaZero

  • Illustrates: How game environments serve as rigorous testbeds for studying intelligence and reinforcement learning scaling.
  • Lesson: Closed-loop environments with clear success criteria accelerate research breakthroughs.

Actionable Takeaways

  • Immediate:
    • Keep pace with Gemini model updates (Flash, Pro, Ultra variants).
    • Embrace agentic coding and developer tool integrations.
  • Strategic:
    • Recognize that software engineering is the ultimate proxy domain for general agentic capability.
    • Leverage full-stack infrastructure advantages for long-horizon AI research.
  • Questions to investigate:
    • How will agentic workflows transform enterprise software development?
    • What are the scaling limits of reinforcement learning in frontier models?

Claims Worth Verifying

  • Google invested in AI chips 15 years ago before mainstream AI adoption. (historical)
  • Software engineering is the most critical domain for AGI development. (architectural)

Notable Quotes

"There's always a lot of discussion about, is there a test for AGI?" (at 0:00) "Software engineering is the most critical domain and environment that you want your systems to be successful in." (at 18:20) "I am very excited, the team is very excited." (at 34:40) "You have to like the journey to be able to achieve something." (at 318:20)

Compressed Summary

  • Rapid Gemini model iteration highlights capability acceleration.
  • Software engineering serves as the primary benchmark and testbed for AGI agents.
  • DeepMind's history of RL and games informs modern LLM agent design.
  • Google's full-stack infrastructure provides a unique advantage for frontier research.
  • Keywords: frontier, agi, gemini, deepmind, agents
  • Core insight: Building AGI requires pushing capability frontiers through agentic workflows, combining deep learning with reinforcement learning, and leveraging full-stack infrastructure.

Core insights

5
Mental Modelmedium noveltystrong evidence

Software engineering is deliberately chosen as the root domain for AGI because code is the one environment that simultaneously forces tool integration, planning, rigorous tooling use, and long-horizon execution. Coding competence is therefore used as a proxy for general agentic capability, not just an application benchmark.

Why it matters

Engineers deciding which agent use-case to build first should favor domains that exercise the full agent loop (tool use, state, long workflows, verification). Software engineering is not incidental; it is the testbed that concentrates those primitives.

Generalization

A good agentic test domain is one where a correct outcome is observable and the solution path forces many distinct agent primitives rather than one model ability.

Software engineering is the most critical domain and environment that you want your systems to be successful in.
Open source video
Coding requires rigorous tooling use, planning, and long-horizon execution.
Open source video
Mechanismmedium noveltymoderate evidence

DeepMind's route from AlphaGo/AlphaFold to frontier LLMs is a carry-over of one design recipe: learned representations are combined with reinforcement learning and exploration to reach capabilities that scaling or static data alone cannot produce. Agentic RL and feedback loops are central to post-training, not a post-hoc fine-tune.

Why it matters

Agent systems should be designed with execution feedback loops that can produce RL-style training signal, e.g., capturing success/failure, tool outcomes, and debugging traces, rather than treating inference as the end of the pipeline.

Generalization

Any agentic architecture that cannot close a feedback loop between action, environment result, and model update is leaving the main mechanism for capability growth unused.

RL and agentic feedback loops are critical for post-training improvement.
Open source video
AlphaGo as the first major proof point of combining deep learning and reinforcement learning.
Open source video
Empirical Resultmedium noveltymoderate evidence

Closed-loop environments with clear success criteria are core accelerants of research speed. Games were the early instances (AlphaGo/AlphaZero), and software engineering with execution is the current instance of the same pattern, meaning designing evaluators and sandboxes is as strategic as designing the model.

Why it matters

For coding agents, a meaningful harness needs more than unit tests: it must observe intermediate actions, execute code, and return unambiguous success/failure signals so the loop can improve.

Generalization

When choosing or building an agent benchmark, invest in environment realism and reward clarity; sparse or ambiguous feedback slows RL-driven iteration.

Closed-loop environments with clear success criteria accelerate research breakthroughs.
Open source video
Architecturemedium noveltymoderate evidence

At the frontier, model capability is inseparable from full-stack control: chips/infrastructure, pre-training, architecture innovation, agentic RL, and consumer ecosystem must iterate together. This is why DeepMind/Google's multi-decade bets on TPUs and compute matter for AGI output and why the model itself is not an isolated artifact.

Why it matters

Organizations building frontier agent products need to decide whether they are full-stack builders or consumers; capability jumps increasingly depend on co-designing infra, training, and agent environments rather than optimizing a single API call.

Generalization

The effective unit of frontier AI engineering is becoming a full product-software-hardware loop, not an isolated model or dataset improvement.

Building AGI requires the full stack of infrastructure, compute, and consumer reach.
Open source video
Google investing in TPU chips and AI research 15 years ago before AI was mainstream.
Open source video
Practicelow noveltystrong evidence

The architectural shift from models to agents means applications must stop treating AI as a text-in/text-out function and begin exposing tools, file/codebase access, execution context, and boundaries for autonomous multi-step action. The agent, not the prompt, is the integration surface.

Why it matters

Enterprise software that wants autonomous coding or general agent workflows needs new operational boundaries: sandboxed execution, strict tool permissions, and developer-facing APIs for the agent's actions, while still allowing a human to review and override.

Generalization

When building on any frontier model, the abstraction boundary should be modeled as an agent in an environment with tools and policy constraints, not as a language model returning text.

Models transitioning from simple text generation to coding agents that write, debug, and execute code.
Open source video
Developers must design applications expecting AI to act autonomously with tools.
Open source video

Deep dives

5

Formalizing success criteria for long-horizon coding agents when unit tests are partial signals

Research question

What combination of unit tests, runtime logs, differential analysis, and human-corrected failure traces provides a reliable reward signal for long-horizon coding agents while preserving open-world validity?

Why

Software engineering is the chosen root domain for AGI, but its evaluation signals are incomplete. DeepMind's history shows that closed-loop environments with clear success criteria accelerate research, so coding agents need an execution-aligned verification stack rather than a single test pass/fail.

Software engineering is the most critical domain and environment that you want your systems to be successful in.
Open source video
Coding requires rigorous tooling use, planning, and long-horizon execution.
Open source video
Source video

Turning evaluation benchmarks into RL-ready training environments

Research question

How should agent evaluation environments be designed so that their success signals are dense enough to drive reinforcement learning, not just produce a terminal benchmark score?

Why

DeepMind's AlphaGo-to-Gemini trajectory shows that the same design pattern—closed-loop environments with clear success criteria—accelerates both research speed and agent capability. Most static coding benchmarks remain terminal and open-loop, wasting a source of training signal.

Closed-loop environments with clear success criteria accelerate research breakthroughs.
Open source video
Source video

Closing the loop between agent execution traces and post-training RL

Research question

What data formats, logging boundaries, and feedback mechanisms are required so that production and sandbox coding-agent traces can be routinely routed back into post-training and evaluation?

Why

The DeepMind recipe moves RL and agentic feedback loops into post-training. If an agent system cannot close the loop between action, environment result, and model update, it is leaving the main mechanism for capability growth unused.

RL and agentic feedback loops are critical for post-training improvement.
Open source video
Models transitioning from simple text generation to coding agents that write, debug, and execute code.
Open source video
Source video

Agentic application boundaries for autonomous tool use and code execution

Research question

What APIs, sandboxing rules, and human-review controls make coding agents reliable integration surfaces for enterprise workflows that previously assumed text-in/text-out model behavior?

Why

Frontier models are shifting from text generation to autonomous, multi-step action. Applications must expose tools, file/codebase access, execution context, and explicit boundaries for action, and treat the agent itself as the integration surface.

Models transitioning from simple text generation to coding agents that write, debug, and execute code.
Open source video
Developers must design applications expecting AI to act autonomously with tools.
Open source video
Source video

Full-stack frontier iteration and downstream model uncertainty

Research question

When a frontier lab iterates architecture, pretraining, RL, infrastructure, and product together on a three-week cadence, what evaluation and integration strategies should downstream engineering teams adopt?

Why

Model capability at the frontier is inseparable from full-stack control. Rapid releases are a deliberate consequence of that co-design, forcing consumers to treat each frontier model as part of a changing system rather than a stable API.

Building AGI requires the full stack of infrastructure, compute, and consumer reach.
Open source video
Google investing in TPU chips and AI research 15 years ago before AI was mainstream.
Open source video
Releasing 2.5 at IO, followed quickly by 3.6 and 3.7.
Open source video
Source video

Article ideas

4

The agent is not the LLM: why code is the first real AGI testbed

Software engineering is not just another application for AI; it is the most complete forcing function that makes an AI system plan, use tools, execute long-horizon work, verify its own output, and recover from failure. Any organization that wants agentic capability should build its first agents on code.

Angle

A management and architecture argument that coding agents deserve flagship status in enterprise AI roadmaps.

Source video

Your coding agent's debug log is your next training set

Execution traces from coding agents—failed attempts, tool outputs, test failures, and successful corrections—are not just operations telemetry. They are the highest-value post-training data a lab or engineering organization can generate, because they are exactly the RL feedback loops that drive frontier capability.

Angle

Turn observability and sandboxing from a compliance concern into model-quality infrastructure.

Source video

Stop designing benchmarks, start designing environments

Static coding benchmark scores are terminal artifacts. The teams that will win with agents are the ones that build closed-loop environments that execute code, observe intermediate actions, and return learnable reward signals, because those environments are simultaneously research accelerators and evaluation harnesses.

Angle

A provocation aimed at AI evaluation culture, inspired by the AlphaGo-to-Gemini design recipe.

Source video

The full-stack frontier: what rapid Gemini releases mean for your model dependency strategy

When frontier model progress is driven by co-design of chips, architecture, post-training, and product, downstream teams can no longer depend on model stability. The correct response is a model-agnostic evaluation and agent harness that treats every release as a system change.

Angle

Strategic advice for engineering leaders building products on top of fast-moving frontier APIs.

Source video

Project ideas

3

Corrective Trace Training

new

Fine-tuning a coding agent on execution traces that pair failed attempts with successful corrective actions improves end-to-end coding task resolution by at least 10 percentage points over the same agent fine-tuned on static problem-to-solution examples.

Proof of concept

Build a constrained Python issue runner in containers; run a small open-weights coding model on 50 debug tasks; log execution traces with test outcomes; construct successful corrections from repeated attempts; fine-tune the model with DPO on contrastive trace pairs; evaluate on 20 held-out tasks not used in training.

Measurement

Held-out task resolution rate, average iterations-to-success, patch pass@1, and stepwise improvement compared against static fine-tuning and zero-shot baselines.

Source video

ExecReward Eval Harness

beyond-evals

An execution-based reward for coding agents that combines unit-test outcomes with runtime exception logs, file-system modifications, and coverage information is at least 0.2 higher in Spearman correlation with human quality judgments than a binary unit-test pass/fail reward.

Proof of concept

Create a sandboxed environment for 30 synthetic Python issues; collect five candidate agent trajectories per task with full runtime logs; record binary test results, error signals, source diff characteristics, and human annotations of quality; compute rank correlations between proposed reward variants and human ratings.

Measurement

Spearman correlation between each reward signal and human quality scores, inter-rater agreement, and sensitivity analysis across task difficulty.

Source video

Agent Sandbox Gateway

gatehouse

Exposing a coding agent's actions as typed, permission-checked, and human-reviewable tool calls reduces unrecoverable operational errors by at least 50% compared with free-form shell execution, while increasing median task completion time by no more than 25%.

Proof of concept

Implement a thin gateway layer in front of a coding agent that intercepts each command or file write, enforces allow/deny policies, and can pause for human approval; run the same tasks in a controlled container environment with and without the gateway; log errors, overrides, and completion times.

Measurement

Count of destructive or unrecoverable actions, policy violations, human override rate, task success rate, and median completion time in gated versus ungated modes.

Source video

Architectural implications

4

Software engineering is the designated root domain where agents must write, debug, execute, and iterate over code.

Before

Model wrappers returned code snippets; reliability depended on prompt quality.

After

Agent runtime owns codebase navigation, tool invocation, shell/test execution, and a feedback loop that uses results to repair code.

Consequence

Product architecture shifts from prompt engineering to workspace state, sandboxing, and failure recovery.

Source video

RL and agentic feedback loops are carried into post-training, not confined to AlphaGo-style game environments.

Before

Training and serving are separate; deployment logs are not used as training signal.

After

Production/sandbox agent traces (tool outputs, test failures, successful patches) are routed back into post-training and evaluation.

Consequence

Observability becomes model-quality infrastructure; logging is designed to be consumed as future training data.

Source video

Closed-loop environments with success criteria are treated as research accelerants.

Before

Evaluation is a terminal benchmark appended to a model release.

After

Evaluation is a reusable environment that provides reward signals for RL and drives iterative model iteration.

Consequence

Teams should invest as much in building and simulating environments and eval harnesses as in model training.

Source video

Google/DeepMind couples rapid model releases with full-stack infrastructure (TPUs, consumer reach).

Before

AI teams consume remote model APIs and cannot change weights or infrastructure to improve capability.

After

DeepMind designs architecture, pretraining, RL post-training, and ecosystem integration jointly in one iteration loop.

Consequence

External developers must treat each frontier release as a different underlying system and keep model-agnostic evaluations; labs need organizational structures that merge research, infra, and product.

Source video

Tradeoffs and failure modes

4

Software engineering as proxy for AGI

Benefit

Forces systems to master tool use and long-horizon tasks with abundant concrete real-world signals.

Cost or risk

Code success is partly measurable through tests, but tests are incomplete proxies; systems optimized for coding environments can underperform in open-ended domains where rewards are less formalized.

Software engineering is the most critical domain and environment that you want your systems to be successful in.
Open source video
Source video

Closed-loop environment design

Benefit

Clear success criteria make RL trainable and accelerate research (AlphaGo/AlphaZero, coding agents).

Cost or risk

The environment is an artificial simplification; breakthroughs may be specific to its reward, and simulation or test-based scoring may not reflect open-world reliability.

Closed-loop environments with clear success criteria accelerate research breakthroughs.
Open source video
Source video

Full-stack frontier iteration

Benefit

Enables rapid capability jumps and integration of model, RL, architecture, and product.

Cost or risk

Concentrates frontier research in a few organizations with large infrastructure; downstream teams face frequent breaking model versions and must continuously re-validate their agent harnesses.

Releasing 2.5 at IO, followed quickly by 3.6 and 3.7.
Open source video
Source video

Frontier-first prioritization

Benefit

Keeps models at the capability edge, treating current performance only as a stepping stone to AGI.

Cost or risk

Under-invests in stability, safety, or incremental productization unless there is a parallel investment in rigorous evaluation and safety.

Current performance is a stepping stone to AGI.
Open source video
Source video

Open questions

3

How should software engineering success criteria be formalized for long-horizon coding agents when tests are only partial signals?

Why unresolved

The summary says closed-loop success criteria accelerate breakthroughs, but code has many valid solutions and no single evaluator.

Research direction

Build execution-aligned verification: combined unit/integration tests, runtime logs, differential comparisons, and human-corrected failure traces.

Source video

What are the scaling limits of reinforcement learning in frontier models?

Why unresolved

RL worked in game environments, but coding and real-world agentic domains have noisier signals and broader action spaces.

Research direction

Benchmark RL scaling against synthetic, well-specified environments versus open-ended production agent traces.

Source video

How will agentic workflows transform enterprise software development?

Why unresolved

Systems are moving from text-in/text-out to long-horizon autonomous execution, and this changes reliability, review, and security assumptions.

Research direction

Study developer workflows that combine human review with autonomous code execution and measure where human intervention adds the most value.

Source video

Key claims

8
factualVerification needed

Google invested in TPU chips and AI research roughly 15 years ago, before AI was mainstream.

Evidence

Google investing in TPU chips and AI research 15 years ago before AI was mainstream.

Question

What funding and timeline evidence establishes Google's AI-chip investment 15 years before mainstream adoption?

Source video
opinionVerification not requested

Software engineering is the most critical domain and environment for AGI development.

Evidence

Software engineering is the most critical domain and environment that you want your systems to be successful in.

Source video
causalVerification needed

Architectural innovations have driven recent capability leaps in frontier models.

Evidence

Architectural innovations have driven recent capability leaps.

Question

Which specific architectural changes are causal in the 2.5-to-3.x generation leaps?

Source video
causalVerification needed

RL and agentic feedback loops are critical for post-training improvement.

Evidence

RL and agentic feedback loops are critical for post-training improvement.

Question

Can controlled ablations show the marginal gain of agentic RL over static fine-tuning on coding benchmarks?

Source video
opinionVerification needed

Closed-loop environments with clear success criteria accelerate research breakthroughs.

Evidence

Closed-loop environments with clear success criteria accelerate research breakthroughs.

Question

With what control or counterfactual comparison can this be measured across RL domains?

Source video
predictionVerification needed

Building AGI requires the full stack of infrastructure, compute, and consumer reach.

Evidence

Building AGI requires the full stack of infrastructure, compute, and consumer reach.

Question

Is there a counterexample of a lab reaching frontier agents without most of the full stack?

Source video
comparativeVerification needed

Models are transitioning from simple text generation to coding agents that write, debug, and execute code.

Evidence

Models transitioning from simple text generation to coding agents that write, debug, and execute code.

Question

What share of production agent workflows today include autonomous code execution rather than text-only code generation?

Source video
predictionVerification needed

There is no substitute for being at the frontier; current performance is a stepping stone to AGI.

Evidence

Current performance is a stepping stone to AGI.

Question

Can meaningful AGI progress be made downstream of frontier models, or does capability always have to be pushed at the frontier?

Source video

Connections

5