Google ADK 1.35.1 Fixes Streaming Truthfulness for Gemini Live Agents

Google ADK Python 1.35.1 is the kind of release that looks too small until you have shipped an agent UI that lies about whether a turn is finished. The patch has two visible fixes: Gemini 3.1 Live grounding metadata is only sent at the end of each turn, and streaming now always yields a final partial=False frame. That is not release-note confetti. That is the contract an application needs if it is going to build reliable workflows on top of live model streams.

Streaming in agent frameworks is often marketed as a UX feature, as if the primary value is making words appear with a pleasing typewriter effect. That framing is too small. In production agents, the stream is a state machine. It tells the frontend what is provisional, tells the workflow engine when a turn can advance, tells the citation layer when evidence is stable, and tells tools or approval gates when downstream action is safe. If the final frame is missing, everything above the framework starts guessing.

GitHub’s API shows v1.35.1 was published on June 15, 2026 at 20:58:49Z, not marked as a prerelease. The repository had roughly 20,123 stars and 3,573 forks at research time. The release has no assets and only a compact set of notes, but the surrounding compare from v1.34.2 to v1.35.1 shows 13 commits across 17 changed files. Nearby work includes Gemini imports in base_llm_flow, history config injection for Gemini 3.1 Live on Vertex AI, default grounding metadata, reconnect-attempt reset after successful connection, and Gemini Live 3.1 input transcription handling. The theme is not hard to spot: Live agents are becoming production plumbing, and the plumbing is being tightened.

The final frame is the latch

A final partial=False event sounds like a tiny detail because humans read final text visually. Machines do not. A web client needs a latch. A workflow runner needs a latch. An evaluation pipeline needs a latch. A logging layer needs a latch. Without a final frame, systems invent one from connection closure, timeouts, empty chunks, or “the model stopped typing for a bit.” Those workarounds are brittle because they confuse transport behavior with semantic completion.

That brittleness gets worse in agent systems. A normal chat app can tolerate a little ambiguity around whether the assistant is done. An agent app may use completion to enable an approval button, start a tool call, unlock the next node in a graph, persist a turn to memory, or render citations as authoritative. If the application treats partial output as final, it can act on text the model would have revised. If it waits forever because no completion event arrives, the user sees a spinner and the developer files the bug under “Gemini latency” when the real problem is event semantics.

ADK’s fix gives developers a cleaner rule: a streamed turn ends when the final partial=False frame arrives. That is the boring rule every production framework should provide. It lets application code stop guessing, and it lets tests assert something specific instead of relying on sleep intervals. In other words, it turns “streaming support” from a demo checkbox into an API contract.

Grounding metadata belongs to completed turns

The grounding metadata change is just as important. Grounding is evidence, not decoration. If a Gemini Live response emits grounding metadata too early or too often, clients can attach citations or retrieval context to output that has not stabilized. For a casual interface, that produces confusing UI. For a research assistant, compliance workflow, customer-support tool, or internal knowledge agent, it becomes a correctness problem: the application may present evidence as supporting a claim before the claim is actually final.

Sending grounding_metadata at the end of each Gemini 3.1 Live turn is the more honest contract. The evidence belongs to the completed turn. It should be consumed after the model has finished the thought, not sprayed across every intermediate update where downstream clients have to infer which citation set is durable.

This is one of the underappreciated differences between “LLM chat” and “agent framework.” A chat transcript can get away with a lot of presentation-layer ambiguity. A framework that advertises graph workflows, multi-agent orchestration, evaluation, deployment, and enterprise-scale reliability cannot. The framework has to decide what events mean and make those meanings stable enough that people build systems on them.

Google’s ADK positioning makes that contract work especially relevant. The docs describe ADK as an open-source, code-first toolkit for building, evaluating, and deploying sophisticated AI agents with flexibility and control. It spans Python, TypeScript, Go, Java, and Kotlin. Its minimal Python example uses from google.adk import Agent, google_search as a tool, and model="gemini-flash-latest". The broader platform story includes graph workflows, multi-agent orchestration, model adapters, local models, deployment, evaluation, and Google Cloud-managed performance, security, and cost controls. That is not a toy surface. It is an attempt to be the production agent substrate for Gemini-heavy teams.

How to upgrade without fooling yourself

If you use ADK with Gemini Live streaming, the practical work is not “bump the package and move on.” Upgrade, then test the event lifecycle explicitly. Assert that every streamed turn emits one final partial=False frame. Assert that grounding metadata arrives at the completed turn boundary. If your frontend renders citations, make sure it only treats them as final after that boundary. If your workflow engine starts downstream nodes from stream completion, use the final frame as the trigger rather than a timeout or connection-close heuristic.

Also inspect your workarounds. Teams that have lived with missing final frames often add defensive code: idle timers, debounce windows, “if no token for N milliseconds, mark final,” or transport-close hooks. Those hacks may have been necessary yesterday. After the framework fixes the contract, stale workarounds can become the new bug. Narrow them. Keep transport recovery code, but let semantic completion come from the semantic event.

For teams comparing ADK against LangChain, CrewAI, Microsoft Agent Framework, AutoGen successors, or custom harnesses, this release suggests a better evaluation question than “does it support streaming?” Ask how the framework represents streaming state. Does it distinguish partial from final? Are citations final-only? Can reconnects reset cleanly after a successful connection? What happens when a live model changes transcription behavior? Can you write deterministic tests around the stream? If the answer is hand-waving, the framework is asking every application above it to solve the hard part again.

The larger market lesson is that production agent frameworks win on event semantics as much as abstractions. Graph diagrams and multi-agent demos are easy to make impressive. Reliable streams are harder, because they force the framework to define the truth at each point in time. ADK 1.35.1 is a small patch, but it fixes the right layer. If the final frame lies or never arrives, the rest of the stack starts guessing. And guessing is not an architecture.

Sources: Google ADK Python v1.35.1 release, Google ADK compare, ADK documentation, Google DeepMind Gemini models