Answers from the documentation; checking which model is on duty
Hi - I answer from the OpenSmartRoute documentation: routing, the API, plans and quotas, self-hosting. Ask away, or open a support ticket if you need a person.
Grounded in the docs - follow a source before acting on it.
Build a voice agent that never goes silent with ADK - OpenSmartRoute
Build a voice agent that never goes silent with ADK
Google released a guide for the Agent Development Kit to build voice agents that stay conversational during long tool calls, using streaming tools and response scheduling.
Key points
Streaming tools cut first word time from 14.4s to 1.2s in benchmarks.
ADK supports non-blocking tools via AsyncGenerator and FunctionTool.
response_scheduling lets you control when results enter the conversation.
Why it matters: Blocking tools create dead air that feels like a dropped call, hurting user trust.
By OpenSmartRoute editorial · written through the router by llm-frontier
From Google AI developers blog - “Step by Step guide: Build a Voice Agent That Never Goes Silent using ADK”
Streaming tools cut dead air - how to make tools talk back to the user.
Silence during a tool call feels like the call has dropped. Users hang up when they hear nothing for too long. A simple database query can take thirteen seconds to finish. That is a long time for a voice conversation to wait.
In text chat, users see a loading spinner instead of silence. They understand the system is working. Voice users cannot see a spinner. They only hear the gap between words.
Google released a guide on building voice agents that never go silent. The guide uses the Agent Development Kit (ADK) and Gemini 3.8 Live. It shows how to use streaming tools to keep the conversation alive.
Streaming tools let the agent speak while work happens in the background. Instead of waiting for a result, the agent sends progress updates. This keeps the audio stream continuous.
The guide explains how to change a standard tool into a streaming tool. You change the return type to an AsyncGenerator. This small change marks the tool as non-blocking.
ADK automatically handles the async status events. The agent speaks immediately upon receiving the request. It does not wait for the full result before answering.
This pattern works well when the work has a story. Connecting, querying, and formatting are distinct steps. The agent can narrate each step as it happens.
Users hear "Connecting to the warehouse" or "Aggregating data." These updates fill the silence. They make the wait feel like active progress.
The guide provides a benchmark sales-report workflow. It compares blocking tools against streaming tools. The results show a massive improvement in speed.
Switching to a streaming tool cut the time to the first word significantly. The time dropped from fourteen point four seconds to one point two seconds.
This means the user hears an answer almost immediately. The agent acknowledges the request and starts talking. The heavy lifting happens silently behind the scenes.
Background execution keeps the agent quiet while work happens.
Google released Gemini 4 Argon to fix a 200,000-line Python codebase in 11 hours. The model cut session prep time by 40% and import times by 21%.
Not every task needs a running commentary. Some waits are just waiting without a story. In these cases, continuous progress updates can feel intrusive.
The guide suggests running tasks quietly in the background. The agent acknowledges the request but stays silent during the work.
This approach uses a single-yield generator. The generator yields only once, right before the result is ready. The agent speaks immediately to confirm it is working.
The agent says, "I am pulling that report together for you now." Then it waits. It does not interrupt the user with status messages.
If the user asks a new question, the agent answers it. The background task continues running. This allows for multitasking and parallel dialogue.
The guide also mentions using FunctionTool with response_scheduling. This lets you keep standard coroutines without changing them. You wrap the function in a tool definition.
You can set the scheduling behavior to WHEN_IDLE. The result waits until the conversation is idle. It does not cut into a current turn.
This pattern is ideal when the user pivots quickly. They ask for a report and then move to another topic. The agent waits for the report to finish.
It delivers the result at the next natural pause. The user does not hear unnecessary chatter. The experience feels natural and unobtrusive.
The guide notes that ADK 2.10+ allows setting behavior to NON_BLOCKING. This runs the tool in the background without modifying the scheduling mode. It simplifies the setup for developers.
You can choose between streaming and background execution based on the task. If the wait has a story, stream it. If the wait is just a wait, run it in the background.
This flexibility helps build responsive voice agents. It prevents dead air without forcing constant updates. The agent remains present throughout complex operations.
response_scheduling controls when results land in the conversation.
The response_scheduling attribute controls when the model reacts to a tool response. It determines the timing of the result delivery. There are three specific behaviors available in ADK.
WHEN_IDLE waits politely while the model finishes speaking. It delivers the result at the next natural pause. This avoids cutting off the user mid-sentence.
INTERRUPT cuts off current speech immediately. The model finishes its answer and then appends the figures. This is useful for critical alerts that need immediate attention.
SILENT adds the result to the conversation history without prompting an announcement. The result is available for subsequent turns. No one hears it unless someone asks.
The guide shows benchmark sessions with gemini-3.8-live. Under WHEN_IDLE, a sales report waited while the model answered a separate question. The figures delivered seamlessly after the question ended.
Under INTERRUPT, the incoming result cut off the current speech. The model finished its answer and then appended the figures. This ensures the user hears the critical data.
Under SILENT, the result was added to the history. It did not prompt an unrequested announcement. The user could ask about the data later if needed.
These scheduling behaviors work with both streaming and single-return tools. Setting response_scheduling on a streaming tool stamps every partial update.
In ADK 2.8 and newer, streaming tools can specify scheduling per update. You can yield types.FunctionResponse with a specific scheduling mode. This gives you granular control over the delivery.
You can keep intermediate progress quiet while delivering the final result. This combines the best of streaming and background execution.
Understanding the trade-off is key. The model receives no payload until the entire function completes in some cases. This means no initial verbal acknowledgment unless the user continues speaking.
This pattern is ideal when the user immediately continues with other questions. The result weaves into the dialogue at the next natural pause.
The execution shape and delivery timing are independent. You can compose them to fit your specific use case. This flexibility is a major advantage of the new ADK features.
Why it matters - silence feels like a broken call.
Silence in a voice call feels like the connection is broken. Users assume the call dropped and they hang up. A ten-second silence makes a web application feel slow.
A conversational voice agent that goes silent for ten seconds feels broken. The user loses trust in the system. They do not know if the system is stuck or busy.
The guide highlights that you cannot always make backend queries sub-second. The fix must be architectural. You must keep the agent conversational while slow tools run.
Forcing custom client-side WebSocket event loops is complex. The open-source ADK and gemini-3.8-live let you implement non-blocking voice tools natively in Python.
This reduces the engineering burden on teams. They do not need to wire up complex event loops themselves. The library handles the asynchronous state management.
The benchmark showed a time reduction from fourteen point four seconds to one point two seconds. This is a dramatic improvement in user experience.
Users hear an answer almost immediately. They do not experience the long gap of silence. The agent acknowledges the request and starts talking.
This matters for cost, speed, quality, and safety. Speed comes from faster response times. Quality improves because the conversation feels natural.
Safety is maintained because the agent does not hallucinate progress. It only speaks what the tool actually sends.
Teams can now build voice assistants that remain attentive. They stay natural and present throughout complex operations. The user experience is significantly better.
How OpenSmartRoute helps - routing live voice sessions to the right model.
Teams that route requests through OpenSmartRoute gain from this news. They can automatically select the best-fit model for live voice sessions. OpenSmartRoute scores every candidate on quality, cost, speed, and safety.
The router sets the weights per request. It learns from outcomes so a model that answers well gets more traffic. A model that fails gets less traffic.
A new model is one catalogue entry and competes on the next request. Nothing else changes in the app. This allows teams to test new capabilities like streaming tools easily.
OpenSmartRoute works with any OpenAI-compatible provider. It supports open-weight models served locally. It also supports MCP tools and A2A agents.
The hosted platform keeps a models catalogue with prices and public rankings. These rankings are built from real traffic. Teams can see which models perform best in practice.
A savings ledger shows what each routed request cost next to the most expensive model. This helps teams manage budget while improving performance.
An input guard spots prompt injection and personal data before a request leaves. This adds a layer of security to the voice sessions.
'osr eval' measures routing accuracy on the team's own prompts. It can fail a build when it drops. This ensures the routing logic remains reliable.
For this specific guide, a team would set up a catalogue entry for gemini-3.8-live. They would enable streaming tools and live scheduling for voice requests.
The team would configure response_scheduling rules based on their workflow. They might set WHEN_IDLE for general queries and INTERRUPT for alerts.
The router would route live voice sessions to the right model automatically. It would ensure the best fit for the streaming tool patterns.
This setup allows the team to test the new ADK patterns at scale. They can see the cost savings and quality improvements in real time.
The team can monitor the savings ledger to track the benefits. They can adjust the weights if the results change over time.
What to do - try the patterns in the interactive demo.
You can try the patterns in the interactive demo. The demo runs the same thirteen-second query through every tool pattern. It tests every response_scheduling mode on gemini-3.8-live.
You can hear the difference between blocking and streaming tools. You can hear the difference between WHEN_IDLE and INTERRUPT.
The guide provides a one-minute ADK Live AI Concierge demo video. It explains how scheduled responses work in action. You can watch it to understand the concepts better.
Start by reading the guide on streaming tools. Understand how to change a tool to an AsyncGenerator. Then try the code examples in the guide.
Next, explore the background execution patterns. Try the single-yield generator approach first. Then experiment with FunctionTool and response_scheduling.
Finally, run the interactive demo. Compare the audio output of each pattern. Listen for dead air and progress updates.
Check the ADK documentation for the latest updates. Look for version 2.10+ features like NON_BLOCKING behavior.
Test your own voice agent with these patterns. Measure the time to the first word. Compare it to your current blocking approach.
Share your findings with your team. See how the new patterns improve your user experience. Use the savings ledger to track your improvements.
The goal is to build a voice agent that never goes silent. Use these tools to keep the conversation alive. Your users will thank you for the seamless experience.
SpaceXAI released Grok Voice 3.0, which scored 86.9 on the Artificial Analysis Speech-to-Speech Index. It is the top-ranked model for speech-to-speech tasks.
