At Google DeepMind × London AI Hub on 16 September 2026, I met people using agentic coding to build small applications for problems they knew personally. One dad was making tools to support his children's education, giving extra attention to their learning needs. Another person had built a solar-power tracker for his smart home.
Those conversations were as interesting as the technical session. People were turning an everyday frustration into something they could use. Ivan Leo's talk covered the machinery behind that kind of work: the Gemini Interactions API, multimodal tools, and managed agents with persistent environments.
An Interaction Includes the Intermediate Work
Ivan described an interaction as the span from a user's request through the agent's work to the eventual reply. It can include several model steps, tool calls, and tool results.
The API shape used typed inputs and outputs for text, images, audio, and function calls. Each item identifies its content type and retains its place in the sequence. That removes ambiguity about which image or audio segment a piece of text refers to.
Typed function results also let a tool return media as media, rather than disguising it as a string. The model receives that result as part of the interaction. The same general creation pattern can address a model or an agent.
Google's Interactions API overview documents the shared interface, multimodal content, tool orchestration, and server-side state. The documentation checked for these notes lists the API as generally available from June 2026; generateContent remains supported.
Continue With an Interaction ID
The session demonstrated continuation using an interaction identifier. Server-side state supplies earlier context instead of requiring the client to rebuild the exchange for every turn.
That identifier refers to conversation and interaction state. It does not identify the agent's filesystem. The environment ID, discussed later in the session, serves a different purpose.
For longer tasks, Ivan described background execution. Deep research was the example, with runs taking minutes rather than returning a short synchronous response:
- Submit the task for background execution.
- Retain its interaction identifier.
- Poll for status.
- Retrieve the result when it completes.
The overview also documents background execution. The session's timing examples were demonstrations, not a latency guarantee.
Cached Input, Retention, and Deletion
Ivan emphasised cached input because long agent runs repeatedly supply substantial context. My transcript records an illustrative input-to-output ratio around 100:1, with cached input roughly ten times cheaper and an example run costing around 50.
These are session estimates captured from noisy audio, not a pricing table. The notes do not identify enough model and accounting detail to reproduce the comparison. The discussion concerned repeated input across a long run, rather than estimating cost from the final answer alone.
The session also covered retaining and deleting interactions for privacy-sensitive workloads. The recorded retention estimate is not reliable enough to use as a service guarantee; the selected service and configuration determine that behaviour.
Video Tools: Transcript, Audio, and Seeking
The video example used a typed video input with a YouTube URI. Ivan compared supplying video content up front with giving the agent tools to inspect relevant parts during the task.
The tools described in the notes let the agent:
- Retrieve the transcript.
- Retrieve or inspect audio.
- Seek to a time range.
- Inspect relevant frames.
One result could guide the next inspection. A transcript might locate a spoken reference, then a frame or video segment could supply the visual evidence. A silent appearance on screen needs visual inspection; the transcript cannot establish it.
My transcript records more than 75,000 tokens for a large video input versus roughly 411 in the tool-driven example. Those demo figures are unverified. The notes do not establish whether they include all tool responses, how the video was sampled, or what was cached. The demonstrated mechanism was selective inspection, not a general saving for arbitrary video tasks.
Google's video-understanding documentation covers video inputs, timestamps, and clipping intervals.
Two IDs, Two Kinds of State
The managed-agent demonstration separated conversation context from the working sandbox:
| Identifier | State described in the session | Continuation |
|---|---|---|
| Interaction ID | Conversation, requests, and prior actions | Continue the exchange |
| Environment ID | Working files, packages, and sandbox | Return to the working environment |
The sandbox example involved writing a file, reading it back, and running commands against the same environment. A later interaction could return to those files rather than begin with an empty filesystem.
Google's managed-agent environment documentation describes isolated Linux sandboxes, reuse of an environment identifier, and retained filesystem state, including files and installed packages. It also documents lifecycle limits. Retained files do not imply indefinite storage or that every process keeps running between interactions.
From Local Agent to Managed Agent
Ivan described the progression as:
- Iterate locally on the agent and its files.
- Package a version for cloud execution.
- Call the named agent through the interaction interface.
The managed-agent portion was presented around the Antigravity harness. Ivan connected the harness with execution patterns used during model training. That was the account given in the session, not an independently verified description of Google's training system.
The interaction call selected an agent. The environment supplied the tools and filesystem used during its work.
Shell, Tools, and Skills
The session argued that a capable model with shell access can do substantial work without a large, rigid orchestration framework. Google Search and URL context were additional tools discussed.
Skills packaged recurring procedures. A media-analysis script could call Gemini with the appropriate input, letting the surrounding agent invoke that specialised step during a larger task.
My notes describe skills copied into the sandbox, repository, or cloud storage used to prepare the environment. A custom-agent demo showed the agent reporting its role and available skills after creation. Successive commands then used the same working files and packages.
Instructions still have to reach the agent. Code guidelines or procedures that never enter its context or workspace cannot guide the run.
The People Building Their Own Tools
The dad building educational tools and the person tracking solar power were solving problems close enough to recognise what a useful application should do. Agentic coding gave them a way to build it.
To me, creative people have always had an advantage, and they will keep it. As the effort of writing software falls, noticing a problem and imagining a useful solution become even more valuable. The people I met were already putting that creativity to work.
The event listing covers the evening gathering. The daytime talks are collected in the separate Cursor Compile London Series.