Gemini 3.8 Live: Native Speech-to-Speech Voice Agents With the Live API

Google has released Gemini 3.8 Live, a real-time voice model built for natural back-and-forth conversation, plus a sibling called Gemini 3.8 Live Extended Thinking. The second one is meant for harder reasoning while the conversation keeps moving. Both are available in the Gemini API, and Google AI Studio lets you try them without writing any code.

The notable detail is the design. Gemini 3.8 Live isn't a speech-to-text step bolted to an LLM and then to a text-to-speech step. It's a native speech-to-speech model that takes live input and produces spoken output with low latency. That makes it a strong candidate for voice agents, tutors, assistants, customer-support systems and other multimodal apps.

What Gemini 3.8 Live is

Classic voice assistants work as a chain of separate stages:

Your voice → speech-to-text → LLM → text-to-speech → voice response

Each link adds delay.

Gemini 3.8 Live is organized around something else. Google calls it a native audio-to-audio experience that supports real-time interaction, handles multimodal information and can work with tools.

The model accepts text, images, audio and video, and it can produce text and audio. Its specification lists an input limit of 131,072 tokens and an output limit of 65,536 tokens.

Google presents it as the default choice for most low-latency voice agents, in cases where you want natural dialogue and don't want the extra delay of deeper reasoning.

Gemini 3.8 Live versus Extended Thinking

The release actually contains two models:

• Gemini 3.8 Live is tuned for fast, natural conversation. Pick it when latency matters and quick replies are the priority.
• Gemini 3.8 Live Extended Thinking targets harder tasks. It reasons further and can run asynchronous tools in the background while the conversation goes on.

Suppose a caller asks a voice agent to find the cheapest flight, compare the options and pick the one that suits their calendar. An ordinary voice model might go quiet while it works.

The Extended Thinking model can stay engaged while the work happens elsewhere. According to Google, it uses conversational fillers and interim updates while tools run. That matters most for agentic voice applications, and much less for simple voice chatbots.

What it can do

1. Real-time speech-to-speech

The headline feature is native, real-time audio interaction. The system doesn't wait for a full sentence to be transcribed before generating a text reply. The Live API keeps a persistent, two-way session open between your app and Gemini, and it uses WebSockets for that constant exchange.

This matters because a voice agent differs from a normal chatbot. A chatbot waits through a cycle of input, processing and output. A voice agent has to listen, understand, respond, listen again, accept interruptions and carry on. The Live API exists to support that continuous loop.

2. Multimodal input

The model isn't limited to microphone audio. It accepts audio, text, images and video, which opens up more interesting products.

One example is a tutor app. A student points a camera at a math problem and asks the tutor to explain the mistake. The model uses the visual input and answers aloud. The Live API documentation also covers sending video frames as images during a session.

3. Tool calling

Tool use is what turns Gemini 3.8 Live from a talking chatbot into an agent. The Live API supports function calling, so your application can expose functions like these:

check_weather()
search_flights()
book_meeting()
get_order_status()
query_database()
send_email()

Gemini decides when a function is needed. Your app runs it and returns the result to the model. Take a customer who asks about order status:

User:
"What's the status of my order?"

Behind the scenes, the flow looks like this:

        ↓Gemini 3.8 Live        ↓get_order_status(order_id)        ↓Your backend        ↓Order database        ↓Result returned to Gemini        ↓Spoken response

An architecture like this can turn a basic voice assistant into a working operational agent.

4. Google Search grounding

Gemini 3.8 Live can also ground answers with Google Search, which helps for questions that depend on current facts. A user might ask about the latest AI headlines. Rather than relying only on what's stored in the model, the Live API can use Search to fetch fresh information. You switch this on in the session configuration:

tools = [
    {"google_search": {}}
]

That makes real-time voice agents far more useful for apps that handle a lot of information.

5. Interleaved reasoning

Gemini 3.8 Live supports interleaved reasoning as well. Reasoning can happen inside an ongoing multimodal exchange, with no need to switch to a separate text-only reasoning flow. Google's model documentation lists thinking as one of the capabilities of Gemini 3.8 Live, and the Extended Thinking model goes further, with deeper reasoning and asynchronous tool execution during a live conversation.

6. Transcription

The Live API can return transcriptions of both the user's input and the model's output. Developers can capture what the user said and what Gemini answered while the conversation itself stays in audio. That helps with:

• support-call transcripts
• meeting assistants
• voice tutors
• call analytics
• AI interviewers
• voice-driven agents

So you don't have to pick between voice interaction and text logs you can search.

Trying it without building an app

The simplest way to experiment is Google AI Studio, which offers a Live interface for the real-time models. Google's announcement points developers to it: AI Studio Live.

It's a good way to learn how the model behaves before you write any code. You could start with a prompt like:

Explain quantum computing like I'm 12.

Then follow up with:

Now explain it using a real-world analogy.Now ask me questions to test whether I understood it.

You can also test multimodal behavior by supplying visual input and asking Gemini to describe or analyze it.

Using Gemini Live as a developer

Developers reach the Gemini Live API through Google's GenAI SDK. Install it first:

pip install -U google-genai

The current documentation recommends the google-genai SDK for the Live API. You also need a Gemini API key. AI Studio can generate one, and Google advises keeping it in an environment variable and not hard-coding it. On Windows:

set GEMINI_API_KEY=YOUR_API_KEY

On Linux or macOS:

export GEMINI_API_KEY="YOUR_API_KEY"

A basic Python example

The minimal connection is surprisingly short. Start with the imports:

import asyncio
from google import genai

Then create the client, pick the model, and open a session that sends one text message and prints whatever comes back:

client = genai.Client()model = "gemini-3.8-live"config = {
    "response_modalities": ["AUDIO"]
}async def main():    async with client.aio.live.connect(
        model=model,
        config=config
    ) as session:        print("Gemini Live session started")        await session.send_realtime_input(
            text="Explain artificial intelligence in simple words."
        )        async for response in session.receive():            if response.server_content:
                print(response.server_content)if __name__ == "__main__":
    asyncio.run(main())

The call that matters is this one:

client.aio.live.connect()

It doesn't behave like a regular single-request API call. It sets up a persistent live session, and you can keep sending input and receiving output through the same connection.

Sending audio

A real voice app streams audio chunks into the session. The Live API currently expects raw 16-bit PCM at 16 kHz as audio input. First import the types:

from google.genai import types

Then send each chunk like this:

await session.send_realtime_input(
    audio=types.Blob(
        data=audio_chunk,
        mime_type="audio/pcm;rate=16000"
    )
)

Gemini answers with audio, which your app plays back to the user. That's the core building block of a real-time voice agent.

Sending video

Visual frames can be sent during the session too:

await session.send_realtime_input(
    video=types.Blob(
        data=frame,
        mime_type="image/jpeg"
    )
)

Per the documentation, video input is a series of individual image frames, at a maximum of one frame per second for this workflow. A pipeline could look like this:

Camera
   ↓
Frames
   ↓
Gemini 3.8 Live
   ↓
Visual understanding
   ↓
Voice response

Applications such as AI tutors, visual assistants and industrial inspection tools could be built that way.

A voice agent with tools

Now picture an AI banking assistant, where the user asks how much was spent on food this month.

Gemini needs no direct access to your database. You register a function it can ask for:

def get_food_expenses(month):
    # Query your database
    return 18500

Gemini requests that function through function calling. Your app executes it and passes the result back. End to end, the exchange runs like this:

User speaks
      ↓
Gemini 3.8 Live
      ↓
Understands request
      ↓
Calls get_food_expenses()
      ↓
Your backend
      ↓
Database
      ↓
₹18,500
      ↓
Gemini
      ↓
"Your food expenses this month are ₹18,500."

To the user, it feels like one continuous conversation.

Why this matters for agents

Better voice quality isn't the main change. The real shift is the combination of voice, vision, reasoning, tools and real-time interaction in one system. Together they make it possible to build agents that don't merely answer questions but act on what's around them. Some examples:

• A support agent that listens to a customer, reads an uploaded document, looks up the latest account details, calls an internal API and explains the outcome out loud.
• A tutor that listens to a student, looks at a handwritten solution and adapts its explanation to the student's reaction.
• A field-service assistant that sees equipment through a camera while a technician asks questions by voice.

None of that resembles a traditional text chatbot.

Pricing

Google's announcement lists the same rate for Gemini 3.8 Live and Extended Thinking: $0.005 per minute of audio input and $0.018 per minute of audio output. Your actual bill depends heavily on how much users talk and how much audio the model generates. For a voice agent, that's a real design factor, since long conversations pile up audio usage fast.

Gemini 3.8 Live compared with the traditional stack

The core difference fits in two diagrams. The traditional voice stack:

Microphone
   ↓
Speech Recognition
   ↓
LLM
   ↓
Text
   ↓
Text-to-Speech
   ↓
Speaker

And with Gemini 3.8 Live:

Microphone / Camera / Text
          ↓
   Gemini 3.8 Live
          ↓
Audio / Text

The second approach can make the architecture simpler, because you no longer need to join a recognizer, a reasoner and a speech generator by hand. In Google's framing, the Live models are an alternative to cascaded voice pipelines.

A security point you shouldn't skip

An API key is fine for experiments. In a production browser or mobile app, though, never put a long-lived key in client-side code.

Google recommends ephemeral tokens for client-to-server Live API apps, which lowers the risk of exposing standard credentials. A production setup should look more like this:

User Device
     ↓
Your Application
     ↓
Secure Authentication
     ↓
Ephemeral Token
     ↓
Gemini Live API

The permanent Gemini key stays out of the frontend entirely.

Where this leaves voice AI

Gemini 3.8 Live marks a real change in how voice AI gets built. Talking isn't the interesting part, since AI systems already produce very natural speech. What's new is that the model holds a live conversation while processing audio, images, video and text, calls tools, and, in the Extended Thinking variant, does heavier reasoning in the background.

The starting point is easy. Open the Live experience in Google AI Studio, try the model, and move to the Gemini Live API when you're ready to build your own app. The basic stack is now very simple:

User
 ↓
Voice / Camera
 ↓
Gemini 3.8 Live
 ↓
Reasoning + Tools + Search
 ↓
Voice Response

That's what to watch. Voice AI is shifting from a talking chatbot toward real-time multimodal agents that can get things done.