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.
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.
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.
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.
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.
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
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.
AI Edge Gallery brings local models to phones
Google AI Edge Gallery extends the same approach to Android and iOS. Users can download the app and use locally installed models to explore several kinds of input and behavior. The phone becomes both the interface and the machine doing inference.
The capabilities serve different purposes:
- Image descriptions: Give the model an image and ask it to describe the contents.
- Audio transcription: Turn audio into text in multiple languages. Bailey tentatively cites support for over 140 languages; that figure is a qualified claim about language support, not a transcription-quality result for each language.
- Function calling: Try model-driven function calls directly on the device.
- Skills: Explore examples including games, haikus, weather queries and scheduling calendar events.
These examples span content generation and actions. A haiku produces text; scheduling a calendar event involves using a function or skill to do something beyond returning prose. Local inference identifies where the model runs. The recording does not establish that every service reached by a weather or calendar skill also operates offline, so the browser demo’s no-data-sent claim should remain specific to that demonstrated application.
Hardware acceleration is the next deployment choice. On supported phones, AI Edge Gallery can use a device accelerator to perform inference instead of falling back to the CPU. Bailey points to higher-end mobile devices as examples. The mechanism moves the model’s inference work onto available acceleration hardware while keeping execution on the device; support therefore depends on the phone’s hardware.
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.
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.
Resources
Related talks
- 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.
Full transcript
Loading transcript…