Gemini 3.8 Live & 3.8 Live Extended Thinking

Gemini 3.8 Live (gemini-3.8-live) and Gemini 3.8 Live Extended Thinking (gemini-3.8-live-extended-thinking), launched September 15, 2026, are generally available (GA) speech-to-speech models that replace the now-legacy gemini-3.1-flash-live-preview; both are built on Gemini 3 Pro and priced identically at $3.00/1M audio-input tokens (~$0.005/min) and $12.00/1M audio-output tokens (~$0.018/min).

The biggest changes vs. 3.1 Flash Live: asynchronous (NON_BLOCKING) function calling is now the default, proactive audio is permanently on, affective dialog is removed, and Extended Thinking introduces a new asynchronous reasoning protocol in which turnComplete: true no longer means the model is idle — clients must track a new interaction_status field (`IN_PROGRESS`/`IDLE`).

Per Artificial Analysis, 3.8 Live Extended Thinking (High) “debuts at #1 at 82.6” on the Speech-to-Speech Index and “#1 on our Tau Voice benchmark implementation at 68.6%“; the base 3.8 Live is the cost leader at $0.84 per hour of input audio. Note: the Live API itself remains in preview even though the two 3.8 models are GA.

Key Findings

Model identity

• Gemini 3.8 Live — model code gemini-3.8-live. Stable/GA. Released and last-updated September 15, 2026. Positioned as the default option for most low-latency voice agents and real-time dialogue “without reasoning-induced delays.“
• Gemini 3.8 Live Extended Thinking — model code gemini-3.8-live-extended-thinking. Stable/GA. Released September 15, 2026. High-reasoning audio-to-audio model that “processes background reasoning and asynchronous tool calls while streaming continuous audio responses.“
• Gemini 3.1 Flash Live Preview — model code gemini-3.1-flash-live-preview. Legacy preview model. Announced March 26, 2026 (9to5Google: “Gemini Live gets its ‘biggest upgrade yet’ with Gemini 3.1 Flash Live,” described as Google’s “highest-quality audio and voice model yet,” supporting “over 90 languages“). Google now recommends updating to 3.8 Live.
• Both 3.8 models are based on Gemini 3 Pro (“Gemini 3.8 Audio is based on Gemini 3 Pro,” per the model card). Authors of the launch: Tom Ouyang (Principal Engineer) and Malini Jaganathan (Member of Technical Staff), on behalf of the Gemini Audio Team.
• Knowledge cutoff: January 2025 (model card).
• Live API preview status: the capabilities and best-practices guides both carry a “Preview: The Live API is in preview” banner, so the transport/API surface can still change even though the models are GA.

Availability

• 3.8 Live: Gemini API + Google AI Studio (developers); Gemini Enterprise private preview, coming to Gemini Enterprise for Customer Experience (enterprise); Search Live (everyone). The model card also lists the Gemini App and Google Cloud/Vertex AI.
• 3.8 Live Extended Thinking: Gemini API + Google AI Studio; Gemini Enterprise private preview; Gemini Live (everyone); and Google Workspace — Docs Live (Google AI Pro/Ultra subscribers), Gmail Live and Keep Live (all Google AI subscribers).
• Deprecation of 3.1 Flash Live: No shutdown/retirement date is published on the Gemini deprecations page for gemini-3.1-flash-live-preview as of September 2026. It is documented as a “legacy preview model” with a recommendation to update, but no earliest-shutdown date is given (unlike, e.g., gemini-3.1-flash-lite, which has a May 7, 2027 shutdown).

Technical specs (all three models)

• Inputs: text, images, audio, video. Output: text and audio (native audio). Native audio models support only the AUDIO response modality; to get text you must enable output audio transcription.
• Token limits: input 131,072 (128K); output 65,536 (64K). Session context-window limit is 128k tokens for native-audio models (32k for older Live models).
• Audio formats: input is raw 16-bit PCM, little-endian, natively 16kHz (the API resamples if needed; convey rate via MIME `audio/pcm;rate=16000`). Output is always 24kHz 16-bit PCM.
• Video: sent as individual image frames (JPEG/PNG), max 1 frame per second.
• Session duration: audio-only limited to 15 minutes, audio+video to 2 minutes without compression; unlimited with context window compression. WebSocket connection lifetime is ~10 minutes; use session resumption to span reconnects. Resumption tokens are valid 2 hours after the last session terminates; server-side session state is stored up to 24 hours.
• Audio token rat: ~25 tokens per second of audio.
• Language: The Live API capabilities-page table lists 99 languages with BCP-47 codes; Google’s launch materials describe 3.8 Live as supporting “over 97 languages” with automatic detection and mid-conversation switching. Native audio output models automatically choose language and do not support explicitly setting a language code.
• Concurrent sessions: up to 1,000 per project on pay-as-you-go (documented on Vertex AI / Gemini Enterprise Agent Platform). The ai.google.dev rate-limits page does not state a Live-specific concurrency figure and defers to Google AI Studio.
• SynthID: all generated audio is watermarked.

Feature-by-feature comparison

Details

Usage method — connection & endpoints

WebSocket endpoints (identical across Live models):

• Gemini API (AI Studio): wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent
• Vertex AI: wss://{location}-aiplatform.googleapis.com/ws/google.cloud.aiplatform.v1.LlmBidiService/BidiGenerateContent
• – The Thinking guide documents a v1alpha variant of the Gemini API endpoint for the 3.8 models; ephemeral-token connections use v1beta and target ...GenerativeService.BidiGenerateContentConstrained?access_token=....
• Auth: API key via ?key=API_KEY (server-to-server); ephemeral tokens for client-to-server (browser/mobile). Vertex requires billing enabled or setup closes with policy error 1008.
• Ephemeral tokens: created via client.auth_tokens.create(...) or POST https://generativelanguage.googleapis.com/v1beta/auth_tokens. Defaults: 1 minute to start a new session (newSessionExpireTime), 30 minutes to send messages over that connection (expireTime). Only work with the Live API and only v1beta. liveConnectConstraints can lock the model and config.

Python (google-genai):

import asyncio

from google import genai

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("Session started")

        # Send content…

asyncio.run(main())

JavaScript (@google/genai):

import { GoogleGenAI, Modality } from '@google/genai';

const ai = new GoogleGenAI({});

const session = await ai.live.connect({

  model: 'gemini-3.8-live',

  callbacks: { onopen(){}, onmessage(m){}, onerror(e){}, onclose(e){} },

  config: { responseModalities: [Modality.AUDIO] },

});

Extended Thinking config (Python):

config = types.LiveConnectConfig(

    response_modalities=["AUDIO"],

    thinking_config=types.ThinkingConfig(thinking_level="low", include_thoughts=True),

    tools=[types.Tool(function_declarations=[search_flights])]

)

Sending audio / receiving audio (SDK):

# send raw 16kHz PCM

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

# receive 24kHz PCM

async for response in session.receive():

    if response.server_content and response.server_content.model_turn:

        for part in response.server_content.model_turn.parts:

            if part.inline_data:

                audio_data = part.inline_data.data

Setup payload (BidiGenerateContentSetup) — raw JSON

{

  "setup": {

    "model": "models/gemini-3.8-live-extended-thinking",

    "generationConfig": {

      "responseModalities": ["AUDIO"],

      "speechConfig": { "voiceConfig": { "prebuiltVoiceConfig": { "voiceName": "Puck" } } },

      "thinkingConfig": { "thinkingLevel": "LOW" }

    },

    "tools": [{ "functionDeclarations": [{

      "name": "searchFlights", "description": "Searches for flights between cities.",

      "behavior": "NON_BLOCKING",

      "parameters": { "type": "OBJECT", "properties": { "destination": { "type": "STRING" } }, "required": ["destination"] }

    }]}]

  }

}

Server acknowledges with `{"setupComplete": {}}`.

Other setup fields: systemInstruction, realtimeInputConfig.automaticActivityDetection (VAD tuning — disabled, startOfSpeechSensitivity, endOfSpeechSensitivity, prefixPaddingMs, silenceDurationMs), sessionResumption, contextWindowCompression (slidingWindow + triggerTokens), inputAudioTranscription, outputAudioTranscription, mediaResolution. Config cannot be changed while the connection is open (and never the model), though non-model params can change when pausing/resuming via session resumption. System instructions can only be set at session start.

Client-to-server messages

• setup (BidiGenerateContentSetup) — first message; contains config.
• clientContent (send_client_content) — turn-by-turn context with explicit roles user/model; turn_complete=true unconditionally interrupts active generation.
• realtimeInput (send_realtime_input) — audio Blob (audio/pcm;rate=16000), text, video frames (image/jpeg), activityStart/activityEnd (manual VAD), audioStreamEnd (flush cached audio after a pause; also used for hybrid VAD).
• toolResponse (send_tool_response) — list of FunctionResponse with id, name, response, and (for NON_BLOCKING) scheduling.

Audio input example:

{ "realtimeInput": { "audio": { "data": "UklGRiQAAABXQVZF...", "mimeType": "audio/pcm;rate=16000" } } }

Server-to-client messages

• setupComplete — {}.
• serverContent — modelTurn (parts, incl. inlineData 24kHz audio and, with Search, executableCode/codeExecutionResult), turnComplete, interrupted, generationComplete, inputTranscription, outputTranscription, and — for Extended Thinking — interactionStatus.
• toolCall / toolCallCancellation — the latter carries the IDs of pending calls discarded on interruption.
• goAway — pre-disconnect notice with timeLeft.
• sessionResumptionUpdate — carries newHandle for reconnection.
• usageMetadata — totalTokenCount plus responseTokensDetails per modality.

NEW asynchronous reasoning protocol (Extended Thinking)

The central behavioral change: with asynchronous reasoning active, turnComplete: true no longer indicates the model is idle — the server may keep running background reasoning or tool calls. Clients must:

1. 1Keep listening for subsequent server messages (tool calls, audio frames) after turnComplete: true.
2. Track interaction_status: IN_PROGRESS (server still processing user input, background reasoning, or awaiting async tool responses; more output may follow) vs. IDLE (all processing/reasoning/tools finished; safe for new user input).
3. Only return the UI to idle/listening on IDLE.

Extended Thinking message flow (verbatim structure from the docs):

// 1. Spoken filler while background reasoning proceeds

{ "serverContent": { "modelTurn": { "parts": [ { "inlineData": { "mimeType": "audio/pcm;rate=24000", "data": "..." } } ] },

  "turnComplete": true, "interactionStatus": "IN_PROGRESS" } }

// 2. Async tool call, still IN_PROGRESS

{ "toolCall": { "functionCalls": [ { "id": "call_123", "name": "searchFlights", "args": { "destination": "Seattle" } } ] },

  "interactionStatus": "IN_PROGRESS" }

// 3. Client returns tool result

{ "toolResponse": { "functionResponses": [ { "response": { "output": { "flight": "DL 145", "price": "$145" } }, "id": "call_123" } ] } }

// 4. Final answer → session goes IDLE

{ "serverContent": { "modelTurn": { "parts": [ { "inlineData": { "mimeType": "audio/pcm;rate=24000", "data": "..." } } ] },

  "interactionStatus": "IDLE", "turnComplete": true } }

Async function-calling semantics: declare `”behavior“: “NON_BLOCKING“` on function declarations; control timing in the FunctionResponse scheduling: INTERRUPT (stop and report immediately), WHEN_IDLE (wait for a natural pause), SILENT (store and use later). On gemini-3.8-live, NON_BLOCKING is the default, BLOCKING is available for back-compat, and scheduling is supported. On Extended Thinking, only NON_BLOCKING is allowed (BLOCKING is a hard error) and scheduling configs are not supported. Note that in practice (LiveKit/Pipecat integration reports) behavior/scheduling currently apply to all tools at once rather than per-tool.

Migration guide: 3.1 Flash Live → 3.8 Live

1. Model string: gemini-3.1-flash-live-preview → gemini-3.8-live.
2. Thinking: remove thinking_level/thinking_config (not supported on 3.8 Live).
3. Async function calling: NON_BLOCKING is now the default; set behavior: BLOCKING if you need the old sequential semantics; scheduling SILENT/WHEN_IDLE/INTERRUPTED is available.
4. Proactive audio: permanently enabled; setting proactive_audio: false returns an error.
5. Affective dialog: removed from the API; delete any enable_affective_dialog config.
6. Turn coverage: defaults to TURN_INCLUDES_AUDIO_ACTIVITY_AND_ALL_VIDEO — video frames are sent by default, so send frames only when needed to manage context and cost.
7. Response modalities: audio is the supported output; enable output audio transcription if you need a text transcript.
8. The turn lifecycle and turnComplete semantics are otherwise **identical for 3.8 Live (a near-drop-in upgrade)**. Moving to **Extended Thinking is a state-handling refactor** around interaction_status plus mandatory NON_BLOCKING tools.

Extra 3.1-specific constraint you leave behind: on gemini-3.1-flash-live-preview, send_client_content is only for seeding initial context (initial_history_in_client_content: true in history_config); after the first model turn you must switch to send_realtime_input with the text field. On 3.8, send_client_content works throughout the session with explicit roles.

Pricing (official Gemini API pricing page — all three models share ONE price row)

Google lists gemini-3.8-live, gemini-3.8-live-extended-thinking, and gemini-3.1-flash-live-preview together under a single heading (“Our low-latency, audio-to-audio models optimized for real-time voice agents and live dialogue, including background reasoning support with Extended Thinking“), Standard tier only:

• Audio is billed at ~25 tokens/sec, which is what yields the per-minute equivalents.
• Live billing compounds: each turn re-bills all accumulated context-window tokens (up to your configured size), so cost per turn rises as a session lengthens; use contextWindowCompression (e.g., 25,000-token trigger, 8,000-token sliding window) to cap it. Enabling inputAudioTranscription/outputAudioTranscription adds text-output-rate charges on top of audio.
• Because proactive audio is permanently on for both 3.8 models, input tokens are billed the entire time the API is listening (output tokens only when it responds). For 3.1 Flash Live (no proactive audio), you’re billed for audio only when actively streaming input.
• Combined, an hour of voice conversation is roughly $1.38 — per The Decoder (Sep 15, 2026): “An hour of voice conversation costs about $1.38 with Google versus at least $3.00 with OpenAI.“
• Free tier exists for these models (input and output “free of charge“). Rate limits vary by usage tier and are viewable in AI Studio; concurrency of up to 1,000 sessions/project (PayGo) is documented for Vertex/Enterprise.

Benchmarks (Artificial Analysis unless noted; label = non-official third-party)

• Speech-to-Speech Index (composite of speech reasoning, agentic performance, arena preference, task success): per Artificial Analysis, “Gemini 3.8 Live Extended Thinking (High) debuts at #1 at 82.6, ahead of GPT-Live-1 (Astra, medium) at 81.5, Grok Voice Think Fast 2.0 High at 81.3.” Base 3.8 Live is #5 at 76.0; Gemini 3.1 Flash Live High scored 71.5.
• τ-Voice (Sierra agentic benchmark): Extended Thinking “#1 … at 68.6%.” Base 3.8 Live scores ~30.1% — per DataCamp, “a gap of more than 38 points between the two variants,” concluding “If your agent chains tools, the base model is the wrong default.” 3.1 Flash Live was ~37.7%. Google’s blog also cites 35.1% on Sierra’s τ³-banking benchmark for Extended Thinking.
• Big Bench Audio (speech reasoning): per Artificial Analysis, Extended Thinking “scores 97.7% on audio reasoning, ahead of Grok Voice Think Fast 2.0 High at 97.2% and behind Qwen Audio 3.0 Realtime Plus at 99.2%“; base 3.8 Live scores 91.7%.
• Cost per hour of input audio (Big Bench Audio subset): per DataCamp, “Gemini 3.8 Live processes an hour of input audio for $0.84. Extended Thinking costs $3.50 … Grok Voice Think Fast 2.0 costs $4.80, and GPT-Live-1 Astra costs $5.83. Gemini 3.1 Flash Live sat at $1.50 and $1.75 depending on thinking level.“
• Caveat (heise / Artificial Analysis): in the human-preference Speech Agent Arena, both 3.8 variants sit behind their predecessor Gemini 3.1 Flash Live Minimal, and lag it on time-to-first-audio — so the quality/agentic wins do not translate into arena preference or lowest latency. Multiple outlets (Yahoo/Tech, Insider Monkey) note the Extended Thinking lead over GPT-Live-1 Astra is only ~1.1 points and voice benchmark leadership has changed hands repeatedly.

Limitations & safety (model card + docs)

• Both models “may exhibit some of the general limitations of foundation models, such as hallucinations” and “there may also be occasional slowness or timeout issues.” Build retry, verification, and failure-handling logic for transactional apps.
• Voice output is not a completion signal. Wait for the correct state — turnComplete for 3.8 Live, interaction_status: IDLE for Extended Thinking — before treating a booking, lookup, or other action as finished, even when the model sounds done.
• Interruption handling: on VAD-detected barge-in the server sends serverContent with interrupted: true, cancels/discards the in-flight generation and any pending function calls (returning their IDs); immediately clear your client-side audio buffer.
• Frontier Safety: assessed via Gemini 3.7 Flash; Google is “confident that Gemini 3.8 Live and Gemini 3.8 Live Extended Thinking are not likely to reach any T/CCLs.“
• Known reliability issue (community, non-official): on 3.1 Flash Live, GitHub cookbook issues report the model audio freezing mid-conversation over raw WebSocket with no error and ~3-second first-turn latency; relevant context when weighing the 3.8 upgrade and when comparing latency claims.

Recommendations

1. Default to gemini-3.8-live for most voice agents. It is a near-drop-in upgrade from 3.1 Flash Live (swap the model string, delete thinking config) and undercuts every rival on price (~$0.84/hr input audio vs. $4.80 Grok / $5.83 GPT-Live-1 Astra).
2. Use gemini-3.8-live-extended-thinking only when the agent chains multiple tools or needs multi-step reasoning. The τ-Voice gap (68.6% vs. ~30% for the base model) means tool-chaining agents should not default to the base model — but budget for the client-state refactor.
3. Re-architect client state before adopting Extended Thinking: never treat turnComplete: true as idle; gate the “listening” UI and any completion/commit logic on interaction_status: IDLE; declare all tools NON_BLOCKING.
4. Enable contextWindowCompression + sessionResumption for any session beyond a couple of minutes, and handle goAway/generationComplete. This also caps compounding per-turn cost.
5. Use ephemeral tokens (v1beta) for any browser/mobile client-to-server deployment; keep API keys server-side.
6. Decision thresholds: if measured task completion on your workload with base 3.8 Live meets targets, stay on it; escalate to Extended Thinking only when multi-step/tool tasks fail your evals. If time-to-first-audio is your critical KPI, benchmark against 3.1 Flash Live Minimal, which third-party arena data suggests may still be faster. Test with quiet/noisy input, long pauses, tool timeouts, disconnects, expired credentials, and late results — record latency distributions, not just best-case demo latency.

Caveats

Language count: Google’s launch materials say “over 97 languages“; the official capabilities-page table lists 99 languages with BCP-47 codes. 3.1 Flash Live was announced with “over 90 languages.” Both official figures are reported here.

Pricing: the three models share a single price row and are not priced separately; the per-minute figures are Google’s estimates derived from the ~25-token/sec audio rate. Text output includes thinking tokens.

API version inconsistency: Google’s own pages differ — the Thinking guide shows a v1alpha endpoint for the 3.8 models, while the WebSocket reference, get-started, and ephemeral-token docs use v1beta (and ephemeral tokens require v1beta). Verify the version your SDK uses.

Benchmarks: figures beyond Google’s own blog come from Artificial Analysis and secondary press (The Decoder, Yahoo/Tech, heise, DataCamp, Insider Monkey, officechai) — labeled non-official. Voice-benchmark rankings have shifted repeatedly month to month.

No published shutdown date for gemini-3.1-flash-live-preview as of September 2026; “legacy” status is documented (model page last updated 2026-09-15) but no retirement date is set.

Concurrency: the 1,000-concurrent-sessions figure is documented for Vertex AI / Gemini Enterprise Agent Platform; the pure Gemini Developer API rate-limits page gives no fixed public number and defers to AI Studio.

The Extended Thinking async protocol and interaction_status field are new and evolving; third-party SDKs (LiveKit, Pipecat) reported partial support (e.g., per-tool behavior/scheduling not yet configurable) shortly after launch.

Primary official sources