Gemini 3.8 Live Extended Thinking 2026: What Devs Get

Google shipped Gemini 3.8 Live alongside a new Extended Thinking variant, and the combination breaks a constraint developers have fought since the first Live API preview: real-time voice and video sessions could not reason deeply without shattering the conversational illusion. Gemini 3.8 Live Extended Thinking lets a session pause, allocate a thinking budget mid-turn, and return with an answer that actually required work — without tearing down the socket or losing audio context. The voice-agent market has moved past demos into production support desks, in-car assistants, and live coding copilots, where a wrong answer delivered fast beats nothing and loses to a right answer delivered in three seconds. The tradeoff is no longer latency versus quality in the abstract; it is a number you set per turn and pay for per token.

What’s new in Gemini 3.8 Live Extended Thinking

Thinking is now a first-class, per-turn parameter inside a live bidirectional session rather than a model-level setting you lock in at connection time. Previously, the Gemini 3.8 Live API gave you one reasoning posture for the whole session: connect to a fast model that answered in under a second and occasionally guessed, or connect to a reasoning model and accept a noticeable stall on every turn, including “what time is it.” The Extended Thinking variant exposes a thinking_config block you can update between turns, so the same socket answers trivia instantly and then spends four seconds reasoning through a database migration plan.

Second, Google added thinking transparency events to the server-to-client message stream. When the model enters an extended reasoning phase, the session emits a structured signal before audio resumes. This sounds cosmetic, but it is the most useful addition for product teams: it lets you play a “let me think about that” filler, dim a UI, or show a spinner instead of leaving the user staring at silence. Silence in a voice UI reads as a dropped call, and until now you had to infer the stall from a timeout heuristic.

Third, the Gemini Live extended thinking budget is metered separately from input and output tokens. Thinking tokens bill at the output rate but never appear in the transcript, so your cost model needs a third column. Google also raised the session ceiling — longer continuous connections before forced reconnect — and improved context compaction so a long support call does not quietly drop the first ten minutes of what the customer said. The Google Gemini 3.8 release is less a capability jump than a control-surface jump: the model can do what you already wanted, and now you can tell it when.

Why it matters

• Per-turn budgets kill the model-switching hack. The common workaround ran two connections — a fast one for chat, a slow one for hard questions — routed by a classifier. That added a hop, duplicated context, and broke audio continuity. One session with a mutable budget removes an entire infrastructure layer.
• Latency becomes a product decision, not an engineering ceiling. Set a 0-token budget for greetings, 2k for lookups, and 8k for analysis, tuning each against a real user-experience target instead of accepting whatever the model does.
• Thinking transparency events make honest UX possible. Telling a user the assistant is working separates “thoughtful” from “broken.” This is the first Live API surface that lets you do it without guessing.
• Cost control gets granular but riskier. An unbounded budget on a chatty endpoint burns money fast. Gemini Live API pricing now rewards teams that instrument per-turn spend and punishes teams that set one global maximum and forget it.
• Tool calls inside reasoning get more reliable. Extended Thinking plans multi-step tool sequences before executing, which cuts the failure mode where a real-time multimodal AI model fires one tool, misreads the result, and improvises.
• Longer sessions change what you can build. Better compaction plus a higher session ceiling makes hour-long tutoring, onboarding, and diagnostic calls viable without reconnect gymnastics.

How to use Gemini 3.8 Live Extended Thinking today

1. Install or update the SDK. The Live surface moved fast through 2026; pin a recent version rather than whatever is cached in your lockfile.

   pip install --upgrade google-genai
   # or
   npm install @google/genai@latest

2. Set your key. Use an environment variable. Never inline the key in a client bundle — the Live API opens a socket directly from wherever you initialize it.

   export GEMINI_API_KEY="your-key-here"

3. Open a session with a default thinking budget. Start conservative. A budget of 0 gives you standard Live behavior; anything above that trades milliseconds for reasoning.

   import asyncio
   from google import genai
   from google.genai import types
   
   client = genai.Client()
   MODEL = "gemini-3.8-live-extended-thinking"
   
   config = types.LiveConnectConfig(
       response_modalities=["AUDIO"],
       thinking_config=types.ThinkingConfig(
           thinking_budget=1024,
           include_thoughts=True,
       ),
       system_instruction=(
           "You are a support agent. Answer simple questions immediately. "
           "Reason carefully before any answer involving billing or account changes."
       ),
   )
   
   async def main():
       async with client.aio.live.connect(model=MODEL, config=config) as session:
           await session.send_client_content(
               turns={"role": "user", "parts": [{"text": "Why was I charged twice in March?"}]}
           )
           async for message in session.receive():
               if message.server_content and message.server_content.model_turn:
                   for part in message.server_content.model_turn.parts:
                       if getattr(part, "thought", False):
                           print("[thinking]")
                       elif part.inline_data:
                           handle_audio(part.inline_data.data)
   
   asyncio.run(main())

4. Raise or drop the budget mid-session. This is the whole point of the release. Classify the incoming turn cheaply — keyword match, intent model, or your existing router — then update the config before sending.

   HARD_INTENTS = {"billing_dispute", "migration_plan", "code_review"}
   
   async def send_turn(session, text, intent):
       budget = 8192 if intent in HARD_INTENTS else 0
       await session.send_client_content(
           turns={"role": "user", "parts": [{"text": text}]},
           thinking_config=types.ThinkingConfig(thinking_budget=budget),
       )

5. Handle the thinking signal in your UI. Do not leave dead air. The moment you see a thought part, emit a filler cue and a visual state.

   if part.thought:
       ui.set_state("thinking")
       audio.play_filler("one_sec.wav")   # short, non-looping
   else:
       ui.set_state("speaking")

6. Instrument spend before you ship. Log thinking tokens separately from output tokens on every turn, then look at the p95. If your median turn uses 40 thinking tokens and your p95 uses 7,000, your router is misclassifying.

   usage = message.usage_metadata
   log.info(
       "turn_cost",
       extra={
           "input": usage.prompt_token_count,
           "output": usage.candidates_token_count,
           "thinking": getattr(usage, "thoughts_token_count", 0),
       },
   )

7. Set a hard ceiling server-side. Never let a client-supplied budget reach the API unclamped.

   MAX_BUDGET = 8192
   budget = max(0, min(int(requested_budget or 0), MAX_BUDGET))

How it compares

Capability	Gemini 3.8 Live Extended Thinking	Gemini 3 Flash (Live)	OpenAI Realtime	Cascaded STT → LLM → TTS
Per-turn reasoning budget	Yes, mutable mid-session	No	Limited; model-level	Yes, but you build it
Typical first-token latency	~0.4s at budget 0; 2–5s at high budget	~0.3s	~0.5s	1.5–4s end to end
Native video input	Yes	Yes	Partial	Rarely
Reasoning visibility to client	Structured thinking events	None	None	Full — you own the pipeline
Cost profile	Base Live rate plus thinking tokens	Lowest	Comparable to Live base	Three vendors to pay
Best fit	Support, diagnostics, tutoring	Assistants, navigation, FAQ	General voice agents	Maximum control, latency-tolerant

The honest read on Gemini 3.8 vs Gemini 3 Flash: if your assistant answers questions that live in a retrieval index, Flash is still the right call, and Extended Thinking is an expensive way to get the same answer. The moment your agent has to decide something — reconcile conflicting records, plan a sequence of tool calls, judge whether a refund applies — the budget pays for itself in avoided escalations.

What’s next

Watch for the budget to become adaptive. Right now you set the number; the obvious next step is a mode where the model estimates required depth itself and reports what it used, the way non-Live thinking models already do with dynamic budgets. Google has signaled this is on the roadmap, and it would remove the routing classifier most teams are about to build.

The second thing to watch is where thinking transparency goes. Structured events are a start, but the useful version is streamed partial reasoning — enough for an agent to say “I’m checking your March invoices now” out loud instead of playing a generic filler. That requires the model to narrate rather than emit an opaque marker, a genuinely hard safety and product problem rather than a schema change.

Finally, price. The Gemini Live API pricing structure is still shaped by a market where Google is buying share. Thinking tokens billed at the output rate is a reasonable deal today, and it is not guaranteed to stay that way once Live sessions are load-bearing in enterprise contracts. Build your cost instrumentation now, keep your intent router provider-agnostic, and make swapping the model string a config change rather than a rewrite. The teams burned by the next pricing revision will be the ones who hardcoded a single model into forty call sites.

Frequently Asked Questions

Is Gemini 3.8 Live Extended Thinking a separate model or a flag?

It is a distinct model variant with its own model string, but the behavior inside it is controlled by a flag — the per-turn thinking_budget. Setting that budget to 0 gives you performance close to standard Live, so most teams connect to the Extended Thinking variant and dial reasoning up only when a turn needs it.

How much does the thinking budget cost?

Thinking tokens bill at the output token rate and are reported separately in usage_metadata. A 4,000-token reasoning pass on a turn that produces 200 tokens of speech costs roughly twenty times what the spoken answer costs — fine for a billing dispute, absurd for a greeting. Check current rates on Google’s pricing page before modeling spend; they have moved more than once this year.

Does extended thinking break real-time audio?

No. The session stays open and the audio stream resumes after the reasoning phase. What it breaks is the feel of real time, which is why the thinking transparency events exist. If you do not handle them with a filler or visual cue, users will hang up during the pause.

Can I use Extended Thinking with video input?

Yes. It is still a real-time multimodal AI model, so camera and screen-share frames work the same way. Video plus a large thinking budget is the most expensive configuration available, so cap the budget aggressively on video sessions and sample frames rather than streaming every one.

Should I migrate off Gemini 3 Flash Live?

Only if you have a measurable quality problem on hard turns. If your escalation rate and answer-accuracy numbers are healthy on Flash, migrating adds cost and latency for nothing. Run both against a sample of your hardest real transcripts and compare — Gemini 3.8 vs Gemini 3 Flash is a per-workload question, not a general ranking.

What happens if I set the budget too low for a hard question?

The model answers anyway, with whatever reasoning fit in the budget. It does not error or refuse. This is the quiet failure mode: a truncated reasoning pass can produce a confident, wrong answer that looks identical to a good one. Evaluate on hard cases at each budget tier rather than assuming more is linearly better.