# Thinking Deeper in Gemini

Jack Rae

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/8EQo4J2BWKw-thinking-deeper-in-gemini) · [Video](https://www.youtube.com/watch?v=8EQo4J2BWKw)

## Thinking Deeper in Gemini

Gemini’s thinking stage adds an adjustable computation loop before the final answer, opening a new path to better reasoning, finer cost control, and longer investigations.

Basic familiarity with language models and tokens is helpful; recurrent state, attention, and test-time compute are explained as they arise.

### Each solution exposes the next bottleneck

[2:32](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=152s)

How do you improve a language model built from hand-calculated word statistics? In Jack Rae’s historical account, Claude Shannon faced that question in 1948. His word bigram model sampled text using statistics from a textbook. The samples improved on simpler character models, suggesting an obvious direction: scale up the statistics. But that required resources Shannon did not have—digitized human knowledge and modern computing. The example establishes the research approach behind Thinking in **Gemini**: identify the resource limiting intelligence, then change the system to overcome it.

By the 2000s, Google could aggregate language statistics at enormous scale. Rae describes n-gram models trained over trillions of tokens, powering speech recognition and translation. Their next limitation was context: storing statistics for increasingly long word sequences incurred exponential storage growth. More data and computing had made short-context models powerful, but extending the same representation became impractical.

Recurrent neural language models changed what the system stored. Instead of enumerating longer word sequences, an RNN compressed the past into a neural state. That representation could carry information beyond a five-word context, across sentences and even paragraphs. The improvement introduced another constraint, however: a fixed-size state has limited capacity. As more context passes through it, some information is lost.

Attention addressed that information bottleneck by retaining past neural representations and aggregating them on demand. The model no longer had to squeeze everything it might need into one recurrent state. In Rae’s progression, this led from attention to transformers: another architectural change that made a previously limiting resource less restrictive.

![Slide titled “2014” lists the LSTM context bottleneck and attention solution beside a diagram connecting past inputs to a context vector.](https://ai.engineer/api/talk-essay-media/fa999aa36163f30551080af3730eda0157b80b57acf167abda58ed68602fcb1e)

Attention preserves past context beyond a fixed-size recurrent state.

### Give the model more computation before it commits

[5:23](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=323s)

By 2024, conversational models were useful across a wide range of tasks, yet they were still trained to begin answering immediately. This exposed a different bottleneck: **the computation available before committing to an answer**. Test-time compute matters because it is the work the model performs on your particular problem, rather than the work already spent training it.

Mechanically, a request becomes tokens that pass through the model. Computation happens in parallel within a layer and sequentially across layers. For an immediate answer, the architecture provides a bounded amount of processing at that request-to-response transition. This does not mean every request has identical total inference cost; it identifies the limited opportunity to work on a problem before starting the answer.

Making the model larger increases that computation, but it does not provide the full flexibility a user might want. A difficult or valuable problem may justify vastly more effort than a routine request. Rae motivates a possible thousandfold or millionfold range of effort as a user need, not a demonstrated improvement. The desired allocation is also adaptive: spend less on easy questions and more on hard ones, with the model helping decide which is which.

**Thinking inserts a text-generation stage before the final answer.** The model emits intermediate thinking tokens, repeatedly passing through another generation step before deciding to commit. This creates a computation loop whose length can vary by task. Rae describes potentially thousands or tens of thousands of iterations; those are opportunities for additional processing, not a universal multiplier for end-to-end compute. Because the loop has a stopping point, the model can learn how much thinking to perform before answering.

### Outcome rewards teach the model how to think

[8:06](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=486s)

Extra tokens are useful only if the model learns to do useful work with them. After pretraining, Gemini undergoes reinforcement learning on many tasks, receiving positive or negative rewards according to whether it solves them correctly. That outcome feedback shapes how it uses the thinking stage. The training recipe does not need to prescribe every intermediate reasoning step, although Rae recalls that the team initially did not know how much explicit structure would be necessary.

An early integer-prediction example made the mechanism tangible. The model used its thinking tokens to:

1. Propose a hypothesis.
2. Test whether the hypothesis worked.
3. Recognize that its formula failed.
4. Reject that idea and try an alternative approach.

The notable behavior was self-correction before the final response. A general reward signal had encouraged the model to spend computation testing and revising its own proposal, rather than simply extending the first idea it generated.

The learned repertoire extends beyond that example. Models can break a problem into components, explore several possible solutions, draft code fragments and assemble them modularly, perform intermediate calculations, and use tools. These are different ways to use the same added resource: computation devoted to the current problem before delivering an answer.

### A new scaling path and a finer cost control

[10:16](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=616s)

For developers, the immediate benefit is more capable models. Thinking also adds an improvement path alongside the existing ones:

| Improvement path | What can grow or improve |
| --- | --- |
| Pretraining | Training data and model size |
| Post-training | Human-feedback quality and task diversity |
| Thinking | Compute spent on an individual problem |

Rae describes investment across these paths as producing a multiplicative effect. The practical claim is that progress in thinking can compound with improvements to the underlying model, rather than requiring the other approaches to stop paying off.

The launch-history chart illustrates that relationship empirically. It places test-time compute on a logarithmic horizontal axis and reasoning performance across mathematics, code, and science on the vertical dimension. Rae reports that performance rises alongside compute, from the non-thinking **Gemini 2.0 Flash Experimental** at the low-compute end to the first launched **Gemini 2.5 Pro** at the other. This is a comparison across model launches, not a controlled isolation of compute from every other model improvement.

Thinking also changes how an application chooses its cost-performance tradeoff. Selecting a model size provides a discrete choice; setting a thinking budget provides finer control over effort within a model.

| Control | Developer choice |
| --- | --- |
| Model selection | Choose among model sizes and capabilities |
| Thinking budget | Allow more or less reasoning effort |

An application can permit greater expenditure when a stronger answer is worth the cost. In the talk’s 2025 product context, Rae describes thinking budgets as launched for **Gemini 2.5 Flash** and Pro; this is a historical description of token-budget controls, not a specification of today’s API.

### Avoid wasted thought, then extend useful thought

[13:23](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=803s)

The next research goals run in two complementary directions:

- **More efficient thinking:** Make effort adaptive enough that developers need less manual tuning. Rae acknowledges that models sometimes overthink, creating opportunities to reduce latency and cost.
- **Deeper thinking:** Increase the maximum useful inference budget for problems that justify a longer investigation.

Efficiency does not require every answer to arrive immediately. It requires matching the work to the task, while retaining the ability to spend much more when necessary.

Gemini Deep Research provides a familiar interaction pattern: submit a query, let a longer process run, and return for the result. **[Gemini Deep Think](https://blog.google/innovation-and-ai/models-and-research/google-deepmind/google-gemini-updates-io-2025/)** applies that willingness to wait to difficult reasoning problems. At the time of the talk, it was an announced experimental mode built on 2.5 Pro, being introduced to trusted testers. Its mechanism combines deeper chains of thought with parallel chains that can integrate their results. Deep Research is an analogy for the interaction, not a claim that the two systems use identical mechanisms.

Rae reports benefits on difficult multimodal, coding, and mathematics problems. For the USA Math Olympiad, he describes January’s state-of-the-art performance as negligible, then gives the following participant-percentile comparison:

| Model or mode | Rae’s reported participant percentile |
| --- | --- |
| Gemini 2.5 Pro | Approximately 50th |
| Gemini 2.5 Pro with Deep Think | Approximately 65th |

These are participant percentiles, not percentages of questions answered correctly. The talk does not specify the grading, sampling, or compute conditions behind the comparison. Rae also suggests that the newly updated Pro might do better, but supplies no measurement for that update.

![Deep Think slide describes a high-budget thinking mode built on 2.5 Pro and multiple deeper chains of thought, beside a podium comparing o3 (high), 2.5 Pro, and 2.5 Pro Deep Think.](https://ai.engineer/api/talk-essay-media/e91cf1e1174ce8eabb15b2e7c5249ebdb67b0b88a01328c7537c3473ae480f6d)

Deep Think overview with a USA Math Olympiad 2025 comparison.

Improving the base model and improving Deep Think’s algorithms can compound, just as thinking can complement pretraining and post-training. The accompanying proof animation illustrates the intended interaction between reasoning paths: begin with a proof-by-contradiction idea, explore approaches involving Rolle’s theorem and Newton’s inequalities, then integrate them into a correct proof. It conveys how multiple ideas might contribute to a solution; it does not supply enough detail to reconstruct the algebra problem or verify the proof.

### Longer reasoning for substantial coding tasks

[16:03](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=963s)

Open-ended coding offers a different reason to allow longer thinking. The goal is to produce substantial software in one or a few interactions, giving the model time to work through the interconnected pieces. Rae’s example comes from colleagues who used Gemini to build from DeepMind’s original DQN research. The reported output included the training setup, the algorithm, and even an Atari emulator that could play some games.

Rae contrasts work that once took him and his colleagues months with examples now beginning to happen in minutes. That is a development anecdote, not a controlled productivity benchmark or a verified reproduction of the original research. Its significance is the scope of the generated artifact: several coordinated parts of a research system, rather than an isolated function.

### Turn limited starting knowledge into new work

[16:52](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=1012s)

The longer-term reference point is human discovery. Rae wants models to contemplate a small body of knowledge deeply enough to extend it. His motivating analogy is Ramanujan: in Rae’s telling, a mathematician with limited access to the mathematical community and one foundational textbook generated an extraordinary quantity of mathematics through sustained independent thought. The closing slide expresses that idea as a textbook plus Ramanujan yielding volumes of mathematical work.

![Full-screen slide shows a mathematics textbook, a plus sign, Ramanujan’s portrait, an equals sign, and a set of yellow books.](https://ai.engineer/api/talk-essay-media/8fb09bbe16c843a771c03e6342d6764045828c7c6ac0488898adf0705617562c)

“Towards Deeper Thinking”: a mathematics textbook plus Ramanujan leads to volumes of mathematical work.

The corresponding ambition for models is **data-efficient discovery through extended inference**. Rae envisions millions or more inference tokens used to build up knowledge and artifacts, allowing a model to derive more from its starting material. This is a research aspiration, not a demonstrated result: move beyond answering from existing knowledge toward sustained work that can push the frontier of human understanding.

## Resources

- [Gemini 2.5 and Deep Think at Google I/O 2025](https://blog.google/innovation-and-ai/models-and-research/google-deepmind/google-gemini-updates-io-2025/) — Google's announcement of experimental Deep Think, multiple-hypothesis reasoning, and expanded developer controls.
- [Gemini 2.5 technical report](https://arxiv.org/html/2507.06261v1) — Technical account of the Gemini 2.5 family, including Deep Think and benchmark methodology.
- [Gemini thinking documentation](https://ai.google.dev/gemini-api/docs/thinking) — Current guidance for configuring reasoning, handling thought summaries, and understanding thinking-token billing.
- [Playing Atari with Deep Reinforcement Learning](https://arxiv.org/abs/1312.5602) — Early DeepMind research introducing deep Q-learning for Atari games from visual input.
- [Large Language Models in Machine Translation](https://research.google/pubs/large-language-models-in-machine-translation/) — Google's 2007 work on large statistical language models for machine translation.

## Slides

### Thinking Deeper in Gemini

Jack Rae introduces a research perspective on Thinking in Gemini, starting with its potential to unblock bottlenecks toward intelligence.

[0:32](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=32s) [Title slide for Thinking Deeper in Gemini, shown beside presenter Jack Rae.](https://assets.ai.engineer/sites/aiecode2025/sha256/ae954512546e4750c3d08cbcb35f2a4a43df2b99b2a0ca1512f1f27affca55cf.webp)

Thinking Deeper in Gemini

AI Engineer
World’s Fair

JACK RAE
Principal Research Scientist
DeepMind
Microsoft

### Progress and bottlenecks toward intelligence

Jack Rae frames progress toward intelligence around identifying and solving key bottlenecks, then introduces historical examples.

[2:35](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=155s) [Slide states that progress has been marked by identifying and solving key bottlenecks toward intelligence.](https://assets.ai.engineer/sites/aiecode2025/sha256/fa5cd1e47845531d3bcd7aad9d498db5bf7e136bf7b5be363011e9d4fbfb5e00.webp)

Progress has been marked by identifying key bottlenecks towards intelligence

...(and then solving them)

Interface text:
AI Engineer World's Fair
Microsoft
JACK RAE
Principal Research Scientist
DeepMind

### 1948: Shannon's language model

Shannon sampled a 2-gram built from hand-calculated word statistics. Rae identifies scaling the model as the bottleneck, requiring digitized human knowledge and modern computing.

[2:48](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=168s) [Slide describes Shannon's 2-gram model, the need to scale it, and the roles of digitized knowledge and modern computing, alongside his portrait.](https://assets.ai.engineer/sites/aiecode2025/sha256/03ea3ddeb0afe054a71c1075abb342b796c0a04c4eda6add328de9d713c700b8.webp)

1948

Shannon invents the language model

Builds a 2-gram and takes a sample:

...AN ENGLISH WRITER THAT THE CHARACTER OF THIS POINT IS...

Pleased with sample, wishes for better language model.

Bottleneck:
• Need to scale n-gram model

Solution:
• Digitalization of human knowledge
• Modern computing

Interface text:
AI Engineer
World’s Fair
Microsoft
JACK RAE
Principal Research Scientist
DeepMind

[3:01](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=181s) [Slide describing Shannon’s 2-gram model, its scaling bottleneck, and the role of digitized knowledge and computing.](https://assets.ai.engineer/sites/aiecode2025/sha256/e21e215a752cf4fc408efbca1b5b3da195ffa7a0c5620609a864ebcf29fea483.webp)

1948

Shannon invents the language model

Builds a 2-gram and takes a sample:

...AN ENGLISH WRITER THAT THE CHARACTER OF THIS POINT IS...

Pleased with sample, wishes for better language model.

Bottleneck:
• Need to scale n-gram model

Solution:
• Digitalization of human knowledge
• Modern computing

Interface text:
AI Engineer
World’s Fair
aws
JACK RAE
Principal Research Scientist
DeepMind

### 2010: Recurrent neural language models

Google’s n-gram models trained on trillions of tokens, but storage costs grew exponentially with context length. Recurrent neural networks compressed the past into a neural state, allowing them to model longer passages.

[3:36](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=216s) [Slide describing the short-context limitation of n-grams and recurrent neural networks as a solution, alongside a research paper.](https://assets.ai.engineer/sites/aiecode2025/sha256/f8fb9d0b85caf545bc76a7cb8e41b13373853eb6d19defc9af997ff0d4a455de.webp)

2010

Google are training n-gram language models over trillions of tokens

Bottleneck:
• Ngram language models restricted to short context
• Why? Exponential storage cost

Solution:
• #DeepLearning
• Use Recurrent Neural Networks to model text

Paper image:
Recurrent neural network based language model
Tomáš Mikolov, Martin Karafiát, Lukáš Burget, Jan “Honza” Černocký, Sanjeev Khudanpur
Speech@FIT, Brno University of Technology, Czech Republic
Department of Electrical and Computer Engineering, Johns Hopkins University, USA
[redacted]

Abstract
A new recurrent neural network based language model (RNN LM) with applications to speech recognition is presented. [illegible]
Index Terms: language modeling, recurrent neural networks, speech recognition

1. Introduction
[illegible]

Diagram labels: INPUT(t), OUTPUT(t), CONTEXT(t), CONTEXT(t−1)
Figure 1: Simple recurrent neural network.

Interface text:
AI Engineer World’s Fair
Microsoft
JACK RAE
Principal Research Scientist
DeepMind

### 2014: LSTMs and attention

RNNs compress the past into a fixed-size state, making context lossy over moderate horizons. Attention keeps past embeddings available and aggregates them on the fly; transformers followed in 2017.

[4:37](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=277s) [Slide explaining the limited fixed-size context of recurrent networks and attention as a way to preserve history, with an attention diagram.](https://assets.ai.engineer/sites/aiecode2025/sha256/e0c084339ff6835713bc64bf2257f8f4b9b8118a9a3b1f33a1c564ca3a5f0338.webp)

2014

LSTMs are ubiquitous across sequence-learning tasks

Bottleneck:
• Context is lossy over moderate horizons
• Why? RNNs use fixed-size representation of the past

Solution:
• Preserve entire history, by using Attention
• ...Then later, Transformers in 2017

Diagram labels: y₁, y₂, y₃, y₄, y₅, y₆; s₁, s₂; context vector; softmax{<Q,K>}; x₁, x₂, x₃, x₄, x₅, x₆

Interface text:
AI Engineer World's Fair
aws
JACK RAE
Principal Research Scientist
DeepMind

[4:53](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=293s) [Slide describes the fixed-size RNN context bottleneck and attention, with an attention diagram.](https://assets.ai.engineer/sites/aiecode2025/sha256/e47ed4207b2c5471c1d78b3624b702b03289e2369a6ebe72171b33ba07e8fa51.webp)

2014

LSTMs are ubiquitous across sequence-learning tasks

Bottleneck:
• Context is lossy over moderate horizons
• Why? RNNs use fixed-size representation of the past

Solution:
• Preserve entire history, by using Attention
• ...Then later, Transformers in 2017

Diagram labels: y₁, y₂, y₃, y₄, y₅, y₆; s₁, s₂; context vector; softmax{<Q,K>}; x₁, x₂, x₃, x₄, x₅, x₆

Interface text:
AI Engineer World's Fair
aws
JACK RAE
Principal Research Scientist
DeepMind

### 2024: Conversational models and test-time compute

Rae describes an inference bottleneck: conversational models are trained to respond immediately, applying a constant amount of test-time compute to move from a request to a response.

[5:29](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=329s) [Slide describes immediate responses as a test-time compute bottleneck, alongside a conversational interface.](https://assets.ai.engineer/sites/aiecode2025/sha256/9c48a207d4f6083dd8aa8b396e6bfdb6e9545a9fec7ae9307c9b82226b3e4c2d.webp)

2024

LLMs have become increasingly general conversational agents

Bottleneck:
• Models are trained to respond immediately to requests

In other words...
• There is constant amount of compute at “test-time” to form a response

Interface text:
Hello, Jack
Design an interactive kaleidoscope
Write requirements for a fitness tracking app
Write a screenplay for a Chemistry 101 video
Create an app for tracking tasks
Ask Gemini
Video
Deep Research
Canvas

### Bottleneck of Test-Time Compute

A request passes through the language model’s layers to produce a response. The speaker describes a fixed amount of test-time compute spent on each particular problem.

[5:59](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=359s) [A request passes through a language model to produce a response, illustrating fixed test-time compute.](https://assets.ai.engineer/sites/aiecode2025/sha256/abc341fb94bf209c9c453bf7f7df00a63b935c40b7cb60d1f3f02e9261862dd6.webp)

Bottleneck of Test-Time Compute

There is a fixed amount of test-time compute to form a response

Request → Language Model → Response

Interface text:
AI Engineer World’s Fair
Microsoft
aws
smol ai

### Adapting Compute to Request Difficulty

Users may want models to spend less compute on simple requests and more on harder ones, including thinking 1,000x harder for very challenging or valuable tasks.

[6:50](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=410s) [The slide proposes spending less compute on simple requests and more on harder ones, including thinking 1,000 times harder for challenging or valuable tasks.](https://assets.ai.engineer/sites/aiecode2025/sha256/c2f4c378562703284bc7a06eab57eb05893844b2c5501b4b473126535c031a50.webp)

Users might want the model to...

Think 1,000x harder for very challenging or valuable tasks.

Spend less compute for simple requests, more compute for harder requests

Interface text:
AI Engineer World’s Fair
Microsoft
aws
smol ai

### Thinking in Gemini

Gemini adds a thinking stage where the model can emit additional text before its final answer. The example response includes a “Show thinking” control.

[7:19](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=439s) [The slide says Gemini models are trained to think before producing a final answer and shows a Gemini response with a Show thinking control.](https://assets.ai.engineer/sites/aiecode2025/sha256/9d301ae4933a6d368659930f92bbda39b9b9c7e5b897692eb49129033fab7440.webp)

Thinking in Gemini

We now train Gemini models to think before emitting a final answer.

What is Thinking in Gemini?
Show thinking

Some Gemini 2.0 models are able to generate the "thinking process" as part of its response. Gemini 2.0 Flash Thinking is an experimental model within the Gemini 2.0 family. Its key distinction from the base

Here's a breakdown of what this means and other key aspects:
• Enhanced Reasoning: By being trained to explicitly output its reasoning steps, Gemini 2.0 Flash Thinking is designed to have stronger reasoning capabilities compared to the standard Gemini 2.0 Flash.
• Experimental Nature: It's important to remember that "Flash Thinking" is currently an experimental offering. This means it might have limited support, and its features or performance could change.
• ...

Interface text:
AI Engineer
World’s Fair
Engineering the future of AI

### Thinking in Gemini: Test-time compute

Gemini inserts a thinking loop between a request and response, allowing more test-time computation. The model can learn how many iterations to run before answering.

[7:33](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=453s) [Diagram showing a request passing through a thinking loop before a response.](https://assets.ai.engineer/sites/aiecode2025/sha256/4f12739e16625756331340de69ce8f29322c6ebcc349b28e23f7260f0bc453d3.webp)

Thinking in Gemini

With a new thinking stage, the model can now spend orders of magnitude more test-time compute before responding

Request → Think → Response

Interface text:
AI Engineer World’s Fair
Microsoft
aws
smol ai

### Thinking in Gemini: Reinforcement learning

After pretraining, Gemini uses rewards for task outcomes to train its thinking stage, shaping how it uses thought tokens to solve tasks.

[8:05](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=485s) [Text and a loop diagram explain training the model to use thought tokens with reinforcement learning.](https://assets.ai.engineer/sites/aiecode2025/sha256/393a1b0ffe42b0958134aa8ab68fbb99b8cc118f5ece3234fb7d1fe53736eb43.webp)

Thinking in Gemini

We train the model to Think with reinforcement learning

The model learns to use thought tokens to solve tasks

Reinforcement Learning

Interface text:
AI Engineer World’s Fair
Microsoft
aws
smol ai

### Emergent Behaviours: Sequence problem

In an early reasoning trace, the model tests and rejects a formula, then tries differences between terms and proposes 202 as the next number.

[8:49](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=529s) [A sequence problem and reasoning trace show a rejected formula, a difference-based approach and the proposed answer 202.](https://assets.ai.engineer/sites/aiecode2025/sha256/8499e3dd0a7a8d93205a33743e04edf6dfcd1031d0a56ba1cb59c6b818fc4765.webp)

Emergent Behaviours

Question
Find the next term in the sequence
2, 6, 22, 56, 114, ...

Let's look at the ratios between consecutive terms:
• a₂/a₁ = 6/2 = 3
• a₃/a₂ = 22/6 = 11/3
• a₄/a₃ = 56/22 = 28/11
• a₅/a₄ = 114/56 = 57/28

The ratios don't seem to follow a clear pattern either.

We can try to express each term as a function of n.
• a₁ = 2 = 2(1) = 2(1²)
• a₂ = 6 = 2(3) = 2(1² + 2)
• a₃ = 22 = 2(11) = 2(1² + 2 + 8) = 2(1² + 2(2²))
• a₄ = 56 = 2(28) = 2(1² + 2 + 8 + 17)
• a₅ = 114 = 2(57) = 2(1² + 2 + 8 + 17 + 29)

It seems that aₙ = 2 ∑ₖ₌₁ⁿ k² = 2 n(n+1)(2n+1)/6 = n(n+1)(2n+1)/3.
Let's check if this formula holds for the given terms:
• a₁ = 1(1+1)(2(1)+1)/3 = 1(2)(3)/3 = 2
• a₂ = 2(2+1)(2(2)+1)/3 = 2(3)(5)/3 = 10 ≠ 6

The formula doesn't hold.

Let's try another approach:

Let the differences between consecutive terms be dₙ = aₙ₊₁ − aₙ.
• d₁ = a₂ − a₁ = 6 − 2 = 4
• d₂ = a₃ − a₂ = 22 − 6 = 16
• d₃ = a₄ − a₃ = 56 − 22 = 34
• d₄ = a₅ − a₄ = 114 − 56 = 58

The first differences are 4, 16, 34, 58, ...

Let the differences between consecutive first differences be dₙ⁽²⁾ = dₙ₊₁ − dₙ.
• d₁⁽²⁾ = d₂ − d₁ = 16 − 4 = 12
• d₂⁽²⁾ = d₃ − d₂ = 34 − 16 = 18
• d₃⁽²⁾ = d₄ − d₃ = 58 − 34 = 24

The second differences are 12, 18, 24, ...

So, the next second difference is d₄⁽²⁾ = d₃⁽²⁾ + d₃⁽³⁾ = 24 + 6 = 30.
The next first difference is d₅ = d₄ + d₄⁽²⁾ = 58 + 30 = 88.
Then a₆ = a₅ + d₅ = 114 + 88 = 202.

Final Answer: The final answer is 202

Interface text:
AI Engineer World's Fair
Engineering the future of AI

[9:01](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=541s) [A sequence problem and a reasoning trace that rejects one formula and tries differences, yielding 202.](https://assets.ai.engineer/sites/aiecode2025/sha256/7de34836b92085cbd31677fb93c65e4b03ae47020e7d21eb9f7e9feafa9bd1ab.webp)

Emergent Behaviours

Question
Find the next term in the sequence
2, 6, 22, 56, 114, ...

Let's look at the ratios between consecutive terms:
• a₂/a₁ = 6/2 = 3
• a₃/a₂ = 22/6 = 11/3
• a₄/a₃ = 56/22 = 28/11
• a₅/a₄ = 114/56 = 57/28

The ratios don't seem to follow a clear pattern either.

We can try to express each term as a function of n.
• a₁ = 2 = 2(1) = 2(1²)
• a₂ = 6 = 2(3) = 2(1² + 2)
• a₃ = 22 = 2(11) = 2(1² + 2 + 8) = 2(1² + 2(2²))
• a₄ = 56 = 2(28) = 2(1² + 2 + 8 + 17)
• a₅ = 114 = 2(57) = 2(1² + 2 + 8 + 17 + 29)

It seems that aₙ = 2 ∑ₖ₌₁ⁿ k² = 2 n(n+1)(2n+1)/6 = n(n+1)(2n+1)/3.
Let's check if this formula holds for the given terms:
• a₁ = 1(1+1)(2(1)+1)/3 = 1(2)(3)/3 = 2
• a₂ = 2(2+1)(2(2)+1)/3 = 2(3)(5)/3 = 10 ≠ 6

The formula doesn't hold.

Let's try another approach:

Let the differences between consecutive terms be dₙ = aₙ₊₁ − aₙ.
• d₁ = a₂ − a₁ = 6 − 2 = 4
• d₂ = a₃ − a₂ = 22 − 6 = 16
• d₃ = a₄ − a₃ = 56 − 22 = 34
• d₄ = a₅ − a₄ = 114 − 56 = 58

The first differences are 4, 16, 34, 58, ...

Let the differences between consecutive first differences be dₙ⁽²⁾ = dₙ₊₁ − dₙ.
• d₁⁽²⁾ = d₂ − d₁ = 16 − 4 = 12
• d₂⁽²⁾ = d₃ − d₂ = 34 − 16 = 18
• d₃⁽²⁾ = d₄ − d₃ = 58 − 34 = 24

The second differences are 12, 18, 24, ...

So, the next second difference is d₄⁽²⁾ = d₃⁽²⁾ + d₃⁽³⁾ = 24 + 6 = 30.
The next first difference is d₅ = d₄ + d₄⁽²⁾ = 58 + 30 = 88.
Then a₆ = a₅ + d₅ = 114 + 88 = 202.

Final Answer: The final answer is 202

Interface text:
AI Engineer World's Fair
Microsoft
aws
smol ai

### Thinking Strategies

The model learns to break problems into components, explore solutions, draft code, calculate intermediate results, and use tools—all ways to spend more test-time compute on a response.

[9:51](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=591s) [Thinking strategies include breaking down problems, exploring solutions, drafting code, calculating, and using tools.](https://assets.ai.engineer/sites/aiecode2025/sha256/e6df31a4ea9de62779886143a19e0652b99f98c829a50ea8875cf0215ed6f5a2.webp)

Thinking Strategies

The model learns to:
🧩 Break down problems into components
💡 Explore multiple possible solutions
📝 Draft fragments of code
🔢 Perform intermediate calculations
🛠️ Use tools

i.e. use more compute and give smarter responses

Event branding: AI Engineer World's Fair; Microsoft; aws; smol ai

### Why Is This Interesting to Developers?

The speaker expects thinking to produce more capable models by adding a new paradigm to existing ways of accelerating model progress.

[10:14](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=614s) [A slide says more capable models and new paradigms accelerate model progress.](https://assets.ai.engineer/sites/aiecode2025/sha256/2b6bf7ddbe30a657c4a9bcb8b36a80c20b399cf4fcdf86936626019983fbc69c.webp)

Why is this interesting to developers?

More capable models!
Each new paradigm accelerates model progress

Event branding: AI Engineer World’s Fair; Microsoft; aws; smol ai

### Scaling More Paradigms

The diagram moves from pretraining alone in 2019 to a 2025 stack that adds post-training and thinking. The speaker says scaling test-time compute alongside the other two paradigms compounds model progress.

[10:37](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=637s) [A diagram adds post-training and thinking to pretraining, illustrating scaling test-time compute.](https://assets.ai.engineer/sites/aiecode2025/sha256/6b3ce8359dee07e28b9df51b301af4df6a4956108e7dc8c1a6744c8091b772dc.webp)

Scaling More Paradigms

Scale test-time compute → Thinking

                 Post-training    Post-training
Pretraining      Pretraining      Pretraining
2019                              2025

Each new paradigm compounds
By scaling all three we can see accelerated progress.

Interface text:
AI Engineer World's Fair
Engineering the future of AI

[10:52](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=652s) [Diagram adds post-training and thinking to pretraining, illustrating compounding progress from scaling all three.](https://assets.ai.engineer/sites/aiecode2025/sha256/1f673d59b45ac4df95c2240553c13fc39ada26244aedb8244bf3bed5af5c296d.webp)

Scaling More Paradigms

Scale test-time compute → Thinking

                 Post-training    Post-training
Pretraining      Pretraining      Pretraining
2019                              2025

Each new paradigm compounds
By scaling all three we can see accelerated progress.

Interface text:
AI Engineer World's Fair
Microsoft
aws
smol ai

### Test-time scaling is working

Across recent Gemini launches, accuracy rises alongside test-time compute on code, math and science benchmarks. Compute is shown on a log scale.

[11:15](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=675s) [Three line charts show increasing accuracy on code, math and STEM benchmarks as test-time compute increases.](https://assets.ai.engineer/sites/aiecode2025/sha256/29e92898dc8d9e068da297e7b54447e3fb2a876ba3f3ad1698e3fdad417ddb6f.webp)

...We see that test-time scaling is working

Code: Live Code Bench v5
Y-axis: Accuracy
Y-axis ticks: 40, 50, 60, 70

Math: AIME 2025
Y-axis: Accuracy
Y-axis ticks: 30, 40, 50, 60, 70, 80, 90

STEM: GPQA
Y-axis: Accuracy
Y-axis ticks: 60, 65, 70, 75, 80, 85
2.0 Flash Exp
2.0 Flash Thinking 1219
2.0 Flash Thinking Exp
2.5 Pro Exp 0325

Test-time Compute (log-scale)

Interface text:
AI Engineer World's Fair
Engineering the future of AI

### Why is this interesting to developers?

Test-time scaling offers developers a way to steer model quality against cost, giving them another dimension to consider when choosing how much to spend on a task.

[12:08](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=728s) [A callout says developers should be empowered to steer cost versus quality.](https://assets.ai.engineer/sites/aiecode2025/sha256/fb9d240119628726d97e2a09bd5a44f9c5b75f777acf058794ca3d4279d1b878.webp)

Why is this interesting to developers?

Want to empower developers to steer cost vs quality

Interface text:
AI Engineer World's Fair
Microsoft
aws
smol ai

### Choose the cost and performance trade-off

Four plotted choices show accuracy rising with cost. The speaker wants to move beyond choosing among discrete model sizes to balance quality and cost for each task.

[12:18](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=738s) [A scatter plot shows four cost and accuracy choices, alongside a call to move beyond a fixed number of choices.](https://assets.ai.engineer/sites/aiecode2025/sha256/6a77831ddea4b4e2b249d348a2c2a1d0150aa1545cf4beb4cfd7bbad3ffff6d2.webp)

You should get to choose how you want to trade off cost and performance

Code: Live Code Bench v5
Y-axis: Accuracy
Y-axis ticks: 40, 50, 60, 70
X-axis: Cost

Want to move beyond having a fixed number of choices for cost versus quality

Interface text:
AI Engineer World's Fair
Engineering the future of AI

### Cost and performance trade-offs

Thinking budgets give users a more granular choice of cost and capability. The chart shows accuracy rising with cost; budgets have launched with Flash 2.5 and Pro 2.5.

[12:36](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=756s) [A chart shows accuracy rising with cost, alongside a note that thinking budgets launched with Flash 2.5 and Pro 2.5.](https://assets.ai.engineer/sites/aiecode2025/sha256/6701271e6b0e5136f728c1d047d79d59045047cebbcf9df776bc700527040f58.webp)

You should get to choose how you want to trade off cost and performance

Code: Live Code Bench v5
Y-axis: Accuracy
Y-axis ticks: 40, 50, 60, 70
X-axis: Cost

Thinking budgets are now launched with Flash 2.5 and Pro 2.5

Interface text:
AI Engineer World's Fair
Engineering the future of AI

### Future directions for thinking

Gemini’s research directions span better reasoning, more efficient thinking, and deeper thinking. The speaker describes reducing overthinking while also scaling inference compute for harder problems.

[13:33](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=813s) [Three directions are listed: better reasoning, better thinking efficiency, and deeper thinking.](https://assets.ai.engineer/sites/aiecode2025/sha256/cb05ca0ce79074f9a7cff77d7df8e70b5ee8dd5433455e74ee46f344d08ac224.webp)

Future Directions for Thinking

More capable models
Better reasoning

Better Thinking efficiency
Better Thinking efficiency

Deeper Thinking
deeper Thinking

Interface text:
AI Engineer World’s Fair
Engineering the future of AI

### Deep Think

Deep Think combines deeper, parallel chains of thought for hard problems. On the 2025 USA Math Olympiad, the slide places 2.5 Pro at the 50th percentile and Deep Think at the 65th.

[14:07](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=847s) [Deep Think is described as a high-budget mode built on 2.5 Pro, with a USA Math Olympiad percentile comparison.](https://assets.ai.engineer/sites/aiecode2025/sha256/abc14e1ce8180a143c8808bd938be673067f093ccaa09554450e1e684e53862e.webp)

Deep Think

Deep Think is a high-budget thinking mode, built on top of 2.5 Pro

Key idea: leverage multiple deeper chains of thought to produce a better response

We find that this approach enhances model performance specially on tough multimodal, code, and math problems

USA Math Olympiad 2025
O3 (high): 35th percentile
2.5 Pro: 50th percentile
2.5 Pro Deep Think: 65th percentile

Interface text:
AI Engineer World’s Fair
Engineering the future of AI

[14:21](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=861s) [Deep Think uses deeper chains of thought; a chart compares USA Math Olympiad percentiles for three models.](https://assets.ai.engineer/sites/aiecode2025/sha256/32c7bb09d3ee1ff03ffd6ada27d7e116987bdd9bcece6210dd388bf909155215.webp)

Deep Think

Deep Think is a high-budget thinking mode, built on top of 2.5 Pro

Key idea: leverage multiple deeper chains of thought to produce a better response

We find that this approach enhances model performance specially on tough multimodal, code, and math problems

USA Math Olympiad 2025
O3 (high): 35th percentile
2.5 Pro: 50th percentile
2.5 Pro Deep Think: 65th percentile

Interface text:
AI Engineer World’s Fair
Microsoft
aws
smol ai

### Vibe-coding a Deep RL training codebase from a paper

Gemini vibe-coded a DQN training setup from the original paper. The Breakout demo’s reward plot shows increasingly variable results, with higher peaks later in training.

[16:01](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=961s) [A Deep Reinforcement Learning paper points to a Breakout training demo with a game display and reward plot.](https://assets.ai.engineer/sites/aiecode2025/sha256/1276bd60cbb44f377cbbaa09a6f0529b80b4ffa3b7151cde6b3c5e21e4cf5f54.webp)

Vibe-coding a Deep RL training codebase from a paper

Playing Atari with Deep Reinforcement Learning
Volodymyr Mnih  Koray Kavukcuoglu  David Silver  Alex Graves  Ioannis Antonoglou
Daan Wierstra  Martin Riedmiller

Simple DQN Breakout Demo (Fast + Plot)
A simplified implementation of DQN playing a basic Breakout game.

Training Progress
Y-axis: Total Reward
Y-axis ticks: -20, 0, 20, 40, 60, 80, 100, 120, 140, 160, 180
X-axis: Episode
X-axis ticks: 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190

Episode: 200 | Total Reward: 36 | Avg Reward (Last 10): 8.4 | Epsilon: 0.01 | Steps: 85731
Status: Training...

Interface text:
Start Training
Stop Training
Game Steps per Frame: 50

## Full transcript

[0:00](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=0s) [upbeat music] [audience cheering] Hi, everybody.

[0:25](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=25s) Uh, yeah, my name is Jack. I'm a researcher at Google, and I'm the tech lead of Thinking within Gemini. And I'm gonna give a brief deep dive into Thinking from the research perspective, uh, within Gemini.

[0:39](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=39s) So, I'm going to kind of give this talk in three stages. One is to give a research motivation of why we actually are excited about Thinking in terms of unblocking bottlenecks towards intelligence.

[0:51](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=51s) And I'm gonna give a kind of, uh, give a few examples of how often discovering the most pressing bottlenecks, uh, in kind of our current, uh, models, uh, our most advanced systems.

[1:03](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=63s) How often if you can just identify the crucial kind of, uh, issues and shortcomings, you often will then find a solution. And there's a reason how that is linked to Thinking.

[1:12](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=72s) I'm then going to talk, um, a little bit more, um, just pragmatically about what is Thinking in Gemini, why is it interesting to developers. And I think you-- someone is...

[1:24](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=84s) Okay. The slides are still not here. We did do a rehearsal this morning where the slides were there. [laughing] But yeah, keynote speaker slide. Yeah. Someone's... I can see someone.

[1:36](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=96s) Yeah. It's the keynote speakers folder. [laughing] Jack Rae.

[1:47](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=107s) I think it's under keynote speaker. That one. [laughing] Um, anyway, um, it's gonna come up soon. You are close, um, person. [laughing] Um, yeah. But, um, and then I'm also gonna talk a little bit about what's next.

[2:03](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=123s) Ah, I'm just... Sorry, I'm just watching. You...

[2:06](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=126s) There you go. Nice one. [laughing] Yeah. That's great. Okay. The slides will appear. Thank you, whoever is coordinator. Apologies, I didn't know what happened. Um, and then I'm just t-gonna talk a bit about what's next.

[2:20](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=140s) So Logan did a great job of kinda giving a, uh, an incredible overview of Gemini as a whole ecosystem, everything that's going on. Uh, I'm gonna really be focusing on, on kind of what we're excited about in, in the reasoning space.

[2:32](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=152s) So with intelligence bottlenecks, uh, we're kind of... The, the message of this section is really about, uh, progress. So progress has really been marked by identifying key bottlenecks towards intelligence and then solving them.

[2:45](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=165s) And, uh, I'm gonna kinda give some examples throughout history. I'm gonna actually rewind the clock to 1948. Claude Shannon, he invents the language model mathematical theory of communication. He builds a language model, a 2-gram, using a, a textbook of word statistics that was hand-calculated, and he samples from it, and he kind of marvels at the samples.

[3:03](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=183s) He feels like, "These are, these are getting pretty good. They're a lot better than unigram character, this 2-gram word model." But, uh, kind of he remarks like, "I think this would be better if we could really, like, make a better language model and scale up this current method."

[3:16](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=196s) So he really wanted to just scale up the n-gram. That was the bottleneck. Like, small amount of data, very s- you know, elementary statistics. And, and unfortunately for Claude Shannon, kind of the solution was pretty hard.

[3:27](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=207s) He needed the digitalization of human knowledge, and he needed modern computing to be able to aggregate these statistics at scale. So, you know, that wasn't so easy for him to solve.

[3:35](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=215s) He had it a bit more tricky. But fast-forward a few decades. At Google, uh, in, in the 2000s, uh, my colleagues such as, uh, Jeff Dean are training n-gram language models over trillions of tokens.

[3:47](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=227s) These are powering, at the time, the most sophisticated speech recognition and translation systems. Uh, and, and a lot of progress has been made. But their bottleneck was actually, uh, with these systems, was that these n-gram language models were very restricted to short context.

[4:00](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=240s) And they were because, um, there was an ex-exponential storage cost with, uh, context length, and there wasn't really a way around that with, with just sticking with n-grams. The solution was the early kind of, uh, introduction of deep learning in 2010, uh, with, uh, the introduction of recurrent, uh, neural l- uh, language models.

[4:19](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=259s) So recurrent neural networks apply to modeling text. Where the recurrent neural networks could avoid this problem by, uh, storing compressed representation of the past into the state of a neural network, and they could now start to model beyond a 5-gram sentences or even paragraphs, and this was a massive kind of, uh, uh, step change and improvement.

[4:37](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=277s) However, a couple of years later, people would notice even there there was a bottleneck. So, uh, the recurrent neural network's representation of the past is in a fixed-size state, and this fixed-size state, uh, uh, there's only so much information you can put into it.

[4:51](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=291s) And so as a result, there's often observed to be kind of lossy, a lossy kind of representation of its context. The solution that was derived, I think once, once people kind of really encountered this, this, um, information bottleneck in the past, was actually just keep everything around in terms of your past, uh, neural, uh, embeddings, and use

[5:09](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=309s) an attention operator to aggregate things on the fly. So this was the birth of attention and then shortly after, transformers. So, um, transformers then kind of led to the modern deep learning revolution as we know it, and, uh, many other progress was made.

[5:23](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=323s) But if we skip forward ten years, we then are in 2024. We have, uh, large language models. They're increasingly powerful general conversational agents. We have, uh, models such as Gemini, ChatGPT.

[5:35](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=335s) People are using them for all sorts of use cases. And there, that's where we kind of come to the bottleneck that's relevant to this talk, which is that although these models are very, very powerful, they're still trained to respond immediately to requests.

[5:47](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=347s) So in other words, in terms of a compute bottleneck, there is a constant amount of compute that they apply at test time to transition from your request or your question to the response or your answer.

[5:58](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=358s) So the bottleneck of test-time compute, this is relevant to Thinking. Uh, so we can unpack this a little bit more. So when we talk about a fixed amount of test-time compute, the test-time compute is interesting to you because that's the compute that the model is spending on your particular problem, your particular question.

[6:14](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=374s) And it

[6:14](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=374s) And, and, and the way it actually kind of mechanically works is you have some text in your request, it gets translated to tokens, and then it's going to go through a language model.

[6:24](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=384s) And at the transition from the request to its response, it's going to pass some computation up through a large language model, which will have some parallel computation for every layer, and it'll have some iterative computation across layers.

[6:36](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=396s) So that computation is really where the model can apply its intelligence to your particular problem, and it's a fixed size. One solution if you wanted a smarter model and more computation is just to make the model larger.

[6:48](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=408s) Then you can have more compute, and you can get a smarter response. However, it's still not really enough. Users might want to be able to think a thousand or a million times and have a very large dynamic range and a lot of compute for very hard or challenging or valuable tasks.

[7:02](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=422s) And also, users might want to have a very dynamic application of test-time compute. So less compute for simpler requests, more compute for harder requests, and have this process be very dynamic and, and, and instigated by the model.

[7:13](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=433s) And that is what motivates thinking. So thinking in Gemini, mechanically, I'm sure almost everyone in this room is familiar with this general process where we will now have a model, and we in-insert a thinking stage, uh, that the model can emit some additional text before it decides to emit a final answer.

[7:34](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=454s) So going back to this notion of test-time compute now, we've added an additional kind of loop, uh, of computation where the model can kind of iteratively, uh, loop and, and perform additional test-time compute, uh, during this thinking stage.

[7:48](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=468s) And this loop can be potentially thousands or tens of thousands of, of iterations, which gives you tens of thousands more, uh, compute before it decides to commit to what its response will be.

[7:57](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=477s) And also because it's a loop, it's dynamic, so the model can learn how many iterations of this loop to apply before it decides to actually commit to its answer.

[8:06](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=486s) We train this model, um, to think, to use this kind of thinking stage via reinforcement learning. So when we pre-train Gemini, uh, we then have after a reinforcement learning stage where we train it to do many different tasks, and we give it positive and negative rewards depending on whether or not it solves the, uh, solves the task

[8:25](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=505s) correctly or not. And this is essentially a very general, uh, training recipe really, and it's kind of remarkable it works. But the model is able to just get a very vague signal of what is correct and what is not correct and to backpropagate this through this loop of thinking stage such that it can try and shape

[8:44](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=524s) how it uses its thinking computation and thinking tokens in order to be more useful. In fact, we weren't really sure this would work. Um, it wasn't clear how much structure we should put into something like a reasoning stage.

[8:57](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=537s) And, um, although I think probably many people here have now seen reasoning traces and played with these models, I'll just show you a historical artifact, um, from one of the times we were trying to use reinforcement learning, we start to see cool emergent behavior.

[9:10](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=550s) So in, in this problem, there's kind of like an integer prediction problem. This was just like a, kind of a, a particular, uh, example. Uh, in this case, kind of like, um, kind of like a math-sy example.

[9:22](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=562s) And what we saw was the model was using its thinking tokens to actually first pose a hypothesis and then test out the hypothesis. And then it found that basically things weren't really working, and it, and it kind of states that this formula doesn't hold.

[9:35](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=575s) It rejects its own idea, and then it tries an alternative approach. And I think it's easy to become desensitized to technology because it's so amazing every single day. But we were truly blown away when we saw the general recipe of reinforcement learning was creating all sorts of interesting emergent behavior, trying different ideas, self-correction.

[9:52](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=592s) And I think these days we see a lot of different strategies that the model learns to do. So it learns to break down, uh, the problem into various components, explore multiple solutions, draft fragments of code and, and, and build these up in a modular way, perform intermediate calculations and use tools, all under the umbrella of using more

[10:12](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=612s) test-time compute to give you a smarter response.

[10:16](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=616s) Okay. So I've talked a bit about, uh, why we are interested in thinking in terms of the path to AGI and unblocking bottlenecks of intelligence and just a little bit about mechanically what it is.

[10:26](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=626s) Why is it interesting to developers? Obviously, the number one reason is we think this is driving, uh, more capable models, and it also stacks on top of our current paradigms of how we accelerate model progress.

[10:38](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=638s) So thinking, uh, we can, uh, kind of accelerate this process by scaling the amount of test-time compute, and we find that this can stack as a paradigm on top of preexisting paradigms such as pre-training, where you can scale the amount of pre-training data and, and, and model size, and also post-training, where you can scale the quality, uh,

[10:58](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=658s) and diversity of human feedback for many different types of tasks. And as a result, by... Within, within Google, by investing in all of these and really accelerating all of them, uh, we get kind of a multiplicative effect.

[11:09](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=669s) And why is this interesting to developers? I think it results in just overall faster model improvement, which is very nice.

[11:17](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=677s) We also see if we kind of, uh, look back over a, uh, a lineage of, uh, recent, um, Gemini launches, um, you know, there's improved reasoning performance and, and we can actually map this to how much test-time compute these models will devote to problems.

[11:33](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=693s) So there's kind of like a log scale test-time compute on the x-axis and performance across like math code and some science topics. And we see that there's kind of this trend in increasing reasoning performance whilst also it tracks very well with increasing test-time compute.

[11:46](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=706s) And on the far left, uh, you know, you have 2.0 Flash Experimental. This was a model that, uh, was not launched with thinking back in, uh, back in December last year, so ancient history.

[11:58](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=718s) Uh, and now we have, uh, uh, on the left, uh, on the right-hand side, what the, the first, uh, launched version of 2.5 Pro.

[12:07](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=727s) So test-time scaling is working empirically. Um, but it's not just capability that matters. It's also interesting from the notion of being able to steer the model's, uh, quality, uh, over cost.

[12:19](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=739s) So, um, you know, before, uh, you had the option of choosing a discrete number of possible model sizes, and that was a way to gauge how much quality you wanted and also how much cost you wanted to spend, um, uh, cost you wanted to kind of incur for any given task.

[12:35](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=755s) But it was kind of a discrete choice.

[12:37](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=757s) Now with Thinking we can have a continuous, uh, budget, uh, which allows you to have a much more granular slider of how much capability you want, uh, for any given kind of class of tasks.

[12:49](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=769s) And we have Thinking budgets now launched in, uh, Flash and Pro, uh, in the 2.5 series. And, um, this allows you to have very granular choice of cost to performance, and also allows us to then push the frontier and, and, and allow you to kind of augment and drive cost higher and performance higher if, if your application

[13:10](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=790s) requires it. So, okay, I think a lot of this stuff is really covering, uh, ground that, you know, uh, up to the present day. So what, what, what's next and what are we excited about?

[13:23](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=803s) So we're, we're very excited about just generally improving the models and having better reasoning, of course. We're also excited about making the thinking process as efficient as possible. Really, we want Thinking to just work for you and be quite adaptive and, and be something that you don't have to actively spend a lot of energy tuning.

[13:39](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=819s) And a big part of that is ensuring our models, uh, are very efficient in how they use their thoughts. Uh, this is definitely an area of progress. I think we can find examples of our models overthinking on tasks, and this is just an area of research to get these things faster and faster and, and as cost effective

[13:54](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=834s) as possible. We're very proud of how cost effective our Gemini models are, and this is just an area, uh, for improvement as well. And there's also deeper Thinking, which is really about scaling the amount of inference compute further to drive even higher capability.

[14:08](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=848s) So people may be familiar with Gemini Deep Research, where you can kind of, uh, type in a query and then, and then the model will go away for a long period of time and research a topic.

[14:17](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=857s) We're also now, uh, have announced at I/O, and we're launching to trusted testers, a notion of Deep Think. Deep Think is a very, a very high budget, uh, mode, um, thinking budget mode built on top of 2.5 Pro, and its desired application is for things where, uh, you have a very hard problem and you're happy to essentially,

[14:34](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=874s) um, uh, fire off the query and then have some asynchronous process that's running for a while and you'll come back to, to arrive at a stronger solution. And its key idea is, uh, we leverage much deeper chains of thought, uh, and parallel, uh, chains of thought that can integrate with each other to produce better responses.

[14:53](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=893s) We find this, uh, enhances model performance on very tough multimodal code math problems. An example would be USA Math Olympiad. This is a task that basically the state-of-the-art model in January was completely negligible performance.

[15:05](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=905s) Uh, 2.5 Pro is now, uh, probably even better, uh, with the, the updated one today. It was about a 50th percentile of all participants that participated in Math Olympiad and, and with Deep Think it goes up to 65, 65, uh, percentile.

[15:19](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=919s) And the interesting thing about Deep Think is as we continue to both improve the base model and improve the algorithmic ingredients that go into Deep Think, those two will stack together as well.

[15:29](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=929s) Um, here is kind of like a, just like a video animation of, of one of these USA Math Olympiad algebra problems. And, and the key idea really with this video is just this notion of having multiple iterative, uh, ideas.

[15:44](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=944s) So maybe the model starts out with some proof by contradiction idea but then explores two different aspects, some Rolle's theorem, Newton's inequalities. It integrates them and eventually arrives at some correct proof.

[15:55](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=955s) There's not that much you can take away from this video, but it looks pretty cool, so I added it. [laughs] Yeah. Yeah.

[16:03](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=963s) One thing that's, you know, other than we talk about math a little bit in the previous slides, I'm very excited about any application where the model can spend longer and longer thinking on very open-ended coding tasks and one shot or very few interaction vibe code, things that would've taken us months, uh, in the past.

[16:19](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=979s) Uh, and one example that I like from a researcher is just, um, um, some of my colleagues kind of vibe coded, uh, from, from DeepMind's original DQN paper, which was a, a revolution in deep reinforcement learning, kind of vibe coded, uh, Gemini vibe coded the, the kind of training setup, the algorithm, uh, even an Atari emulator such

[16:38](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=998s) that it could play some of the games. And, you know, this is, uh, remarkable to me 'cause this, these kind of things would've taken me and my colleagues, uh, months in the past, and these things are starting to happen, um, uh, kind of in minutes.

[16:52](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=1012s) One thing I'm quite excited about looking forward to the future is not really the landscape of models, but coming back to, like, what's our gold standard, which is the human mind.

[17:01](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=1021s) I would love for our models to be able to contemplate from a very small set of knowledge and think about it incredibly deeply such that we can push the frontier.

[17:10](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=1030s) And one example I often think about is Ramanujan, who's, uh, one of the world's greatest mathematicians, uh, from the early 20th century. And famously, he, he just had this one math textbook.

[17:19](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=1039s) He was kind of cut away from, from the mathematical community, but he... Just from a small set of problems he spent, uh, many textbooks' worth of thinking, going through problems, inventing his own theories to further extend ideas, and he invented a, an, an incredible quantity of mathematics really just by deeply, deeply thinking from a small source subset.

[17:41](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=1061s) And this is where I think we are going with Thinking. We want a model to be able to be incredibly data efficient and actually go to millions, uh, or, or beyond of, of, of inference tokens where the model is really building up knowledge and artifacts such that we can eventually start to push the frontier of human understanding.

[18:02](https://www.youtube.com/watch?v=8EQo4J2BWKw&t=1082s) So with that said, thank you very much. [clapping] And, uh, yeah. [upbeat music]
