AI Engineer World's Fair 2026

Research to Reality with Google DeepMind — Paige Bailey, Google DeepMind

Read the talk

Research to Reality with Google DeepMind

Paige Bailey moves from DeepMind’s science mission to a Gemma model running in a browser, then follows local inference onto phones. The practical question is how model size, runtime and quantized checkpoints make those deployments possible.

From a talk by Paige Bailey

At a glance

Ideas worth remembering

  • The browser demonstration runs Gemma through Transformers.js locally, producing a comparison table without sending the prompt to a model API.

  • AI Edge Gallery exposes image descriptions, multilingual audio transcription, function calling and skills on Android and iOS, with device acceleration available on supported hardware.

  • Deployment depends on model size and checkpoint representation together: Bailey reports a quantized 2B checkpoint smaller than one gigabyte and connects QAT checkpoints to the fast browser demo.

From scientific research to agents that can execute tasks

New models become useful when people can put them into their own projects. Paige Bailey, presenting for Google DeepMind, opens with that practical aim: live demonstrations, questions throughout, and room to explore how the models work. The research context comes first. DeepMind’s mission connects responsible AI development with work on protein structure, medical models, robotics, mathematics and frontier research.

Selected presentation frame from Research to Reality with Google DeepMind — Paige Bailey, Google DeepMind at 186 secondsOpen full source frame
A globe fills the right side of a slide reading “Our mission is to build AI responsibly to benefit humanity.”

The first product sketch concerns execution. Managed Agents takes a higher-level task described in natural language and gives a fleet of agents a Linux workstation in a sandbox environment. Skills and dependencies can be added to that environment as work proceeds. The workstation matters because it gives the agents somewhere to carry out the task, with software available to support it. Bailey also introduces a computer use API and a speech-to-speech translation API, although this recording moves into local models before developing those demonstrations.

0:120:42

Gemma gives developers a model they can download and adapt

Gemma 4 supplies the open-model side of this story. Bailey describes a family with 2 billion, 4 billion, 12 billion, 26 billion and 31 billion parameters. The two largest versions use different architectures: the 26B version is a mixture-of-experts model, while the 31B version is dense. These are distinct options within the family, rather than one model that must serve every device.

Selected presentation frame from Research to Reality with Google DeepMind — Paige Bailey, Google DeepMind at 310 secondsOpen full source frame
A Gemma 4 slide shows a model-family chart with the 2026 timeline and “Open Models” at the bottom.

The Apache 2 license is the practical opening for customization. In Bailey’s account, developers can download the models, use them within a company, fine-tune them and build on them for their own projects. That makes deployment location and adaptation part of the developer’s decision: the model can become a component in a locally running application.

“I hate slides,” Bailey says before switching to a community-built browser application. That move makes the deployment question concrete. A downloadable model is useful here because the application can load it directly into the browser and run it on the user’s machine.

4:385:08

A Harry Potter comparison runs entirely in the browser

The browser demo turns a fairly elaborate request into a table. Bailey asks for an emoji comparison of the Harry Potter books, ranked by how funny and exciting they are, with recommendations on what to read. The prompt also asks to incorporate a rationality-themed Harry Potter work. The important change is visible: a prose request becomes a structured comparison containing entries such as The Deathly Hallows, Half-Blood Prince, Order of the Phoenix and Goblet of Fire.

Selected presentation frame from Research to Reality with Google DeepMind — Paige Bailey, Google DeepMind at 435 secondsOpen full source frame
A dark browser page displays a table comparing Harry Potter books with emoji and accompanying text.

The response feels almost instantaneous to Bailey. She immediately questions its taste—“I’m not sure if I agree with the ranking”—which separates the two things this example demonstrates. The model can follow the requested format and produce recommendations quickly; the literary ranking remains a judgment the reader can disagree with. Perceived responsiveness is an observation from this demonstration, rather than a measured latency result.

The execution path explains why no inference API call is needed. The application runs Gemma locally through Transformers.js, with WebAssembly providing the browser execution mechanism Bailey describes. The loaded model handles the prompt on the machine and returns the table to the browser interface. For this demo, Bailey says the user’s data is not sent elsewhere.

Where does the request travel? The diagram keeps the prompt, runtime, loaded model and resulting table inside the same device. Its useful relationship is the return path: the browser receives an answer from local inference, without handing the prompt to a remote model API.

The browser demo’s local inference path

Comparison requestUser’s machine — Ask for emoji, humor and excitement rankings, and reading recommendations.
Browser runtimeUser’s machine — Transformers.js and the WebAssembly execution described in the demo.
Loaded Gemma modelUser’s machine — Runs inference locally, without a model API call.
Generated comparison tableUser’s machine — Returns book entries and recommendations for the user to assess.
The Harry Potter request and generated comparison stay on the machine in the demonstrated application.
Read the diagram as text
  • Comparison request. User’s machine — Ask for emoji, humor and excitement rankings, and reading recommendations.
  • Browser runtime. User’s machine — Transformers.js and the WebAssembly execution described in the demo.
  • Loaded Gemma model. User’s machine — Runs inference locally, without a model API call.
  • Generated comparison table. User’s machine — Returns book entries and recommendations for the user to assess.
  • Comparison request → Browser runtime: Submit the request.
  • Browser runtime → Loaded Gemma model: Run local inference.
  • Loaded Gemma model → Generated comparison table: Generate the response.
6:086:38

Choose the model and checkpoint that fit the device

The ending returns to model size as an operating decision. Bailey describes the 26B and 31B models as performing above expectations for their size, including against models an order of magnitude larger. That comparison comes without a named task or benchmark here, so it supports her deployment motivation rather than a general performance ranking.

Selected presentation frame from Research to Reality with Google DeepMind — Paige Bailey, Google DeepMind at 590 secondsOpen full source frame
A dark slide titled “Model Performance VS Size” shows plotted points and a blue triangular region.

The proposed cost advantage comes from fitting useful inference into less hardware. A model that runs on one commodity GPU needs a smaller GPU footprint and avoids the distributed inference setup that would otherwise spread its execution across machines. Bailey presents a practical range of deployment targets:

  • Single-GPU deployment: The larger variants are intended to run well on a single commodity GPU.
  • Laptop deployment: Versions at 12B parameters and below can run locally on a laptop.
  • Mobile deployment: The 2B version can fit on a phone.

These are deployment categories, not guarantees for every device in them; the recording does not give a minimum memory configuration.

Parameter count is only part of the fit. The released quantized checkpoints provide smaller model representations, and Bailey identifies QAT checkpoints as what the fast browser demonstration used. For the 2 billion parameter version, she reports a checkpoint size of less than one gigabyte. That quantity describes the checkpoint, rather than the total memory consumed by the browser and inference runtime.

This closes the loop on the Harry Potter table. The browser loaded a model, executed the request locally and returned a structured answer; the closing explanation identifies a compact quantized checkpoint as part of what made that deployment practical. The useful choice is therefore more specific than selecting a model family: choose a model size, a checkpoint representation and an execution path that fit the machine where the work should happen.

9:079:37

Resources

  • Beating RL With Reflection: GEPA and Optimize Anything

    A complementary look at making a model useful for a specific task: reflective optimization changes prompts, agent programs and repository skills, with examples of improving smaller models without increasing their size.

Transcript download
Full transcript

Loading transcript…