Time to first token: GPT-5 vs Claude Opus vs Gemini 3

When you’re shipping a chat UI or agent loop, the time to first token GPT-5 vs Claude Opus vs Gemini 3 is the metric that decides whether users see a responsive system or a spinner. TTFT bundles network round-trip, queueing, prefill, and the provider’s decision to stream or buffer. This post compares the three flagship models on the dimensions that actually move the needle in production.

What TTFT actually measures

TTFT is the wall-clock interval from sending the last byte of your request to receiving the first decoded token. It is not generation speed. A model can have terrible tokens-per-second but still post a low TTFT if it streams immediately.

Prefill dominates TTFT for long prompts. The transformer must attend over the full context before emitting anything. Smaller models and TPU-served models often win here not because they think faster, but because they schedule prefill more aggressively.

Network jitter adds 20–100ms per hop. If your client is in Frankfurt and the provider edge is in Iowa, you will never beat physics. Measure TTFT from the same region you serve from.

Measuring TTFT without lying to yourself

Don’t trust a single sample. Run 100 requests, drop the first ten as warmup, and look at p50/p95. Here’s an async snippet that captures TTFT precisely:

import asyncio, time, openai

async def ttft(model):
    client = openai.AsyncOpenAI()
    start = time.perf_counter()
    stream = await client.chat.completions.create(
        model=model, stream=True, messages=[{"role":"user","content":"Explain TCP fast open."}]
    )
    async for chunk in stream:
        if chunk.choices[0].delta.content:
            return time.perf_counter() - start

print(asyncio.run(ttft("gpt-5")))

For a quick manual check, curl with -w measures time to first byte, which is a close proxy:

curl -N https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
  -d '{"model":"gpt-5","stream":true,"messages":[{"role":"user","content":"hi"}]}' \
  -o /dev/null -w "ttfb=%{time_starttransfer}\n"

The same pattern applies to Anthropic and Gemini endpoints; only the JSON shape changes.

Capabilities: reasoning vs throughput

GPT-5 ships with a configurable reasoning budget. If you ask for reasoning_effort: high, the model may internally generate thousands of hidden tokens before the first visible token. That inflates TTFT unpredictably. For straight extraction or summarization, low effort keeps TTFT near the provider baseline.

Claude Opus prioritizes coherent long-form reasoning. Its prefill on 100k+ context windows has historically been slower than mid-tier Anthropic models. You pay for quality with latency.

Gemini 3 is built for multimodal and high-context workloads. Google’s serving stack tends to overlap prefill and decode, which keeps TTFT low even when you attach images or long documents.

Price and cost model

None of these are cheap. Opus sits at the top of the per-token price ladder; GPT-5 uses a tiered structure where reasoning tokens cost extra even if they never surface to the user; Gemini 3 typically offers the lowest marginal cost at high volume, especially if you commit to batch endpoints.

If TTFT is part of your SLA, cost and latency trade off. Cheaper batch APIs increase TTFT by seconds or minutes. Streaming interactive endpoints cost more per token but keep TTFT in the hundreds-of-milliseconds to low-seconds range. Hidden reasoning tokens on GPT-5 can silently triple a line-item.

Latency and throughput characteristics

Measured TTFT varies by region, load, and prompt size. The patterns below are what we see in practice:

• GPT-5: Fast to first token on short prompts (<2k tokens). With reasoning enabled, expect a visible pause. Throughput is solid on Azure and OpenAI direct.
• Claude Opus: Consistent but slower prefill. On long system prompts it can take multiple seconds before the first byte. Streaming starts after full prefill.
• Gemini 3: Lowest baseline TTFT across all context sizes in our tests. Multimodal input doesn’t penalize TTFT as much as on the other two.

If you front your calls with a gateway that provides automatic fallback when a provider is rate-limited or degraded, like n4n.ai, you can mask TTFT spikes by routing to a secondary model without changing client code.

Ergonomics and SDKs

All three expose streaming, but the shapes differ.

# OpenAI-compatible (GPT-5)
from openai import OpenAI
client = OpenAI()
stream = client.chat.completions.create(model="gpt-5", stream=True, messages=[{"role":"user","content":"hi"}])
for chunk in stream:
    if chunk.choices[0].delta.content:
        print("first token", chunk.choices[0].delta.content)
        break

# Anthropic (Claude Opus)
import anthropic
client = anthropic.Client()
with client.messages.stream(model="claude-opus", max_tokens=1024, messages=[{"role":"user","content":"hi"}]) as s:
    for text in s.text_stream:
        print("first token", text)
        break

# Gemini (Google)
import google.generativeai as genai
model = genai.GenerativeModel("gemini-3")
resp = model.generate_content("hi", stream=True)
for chunk in resp:
    print("first token", chunk.text)
    break

GPT-5 and Gemini accept OpenAI-style function calling; Claude uses a native tool format. If you standardize on an OpenAI-compatible endpoint that addresses 240+ models, you avoid rewriting the streaming loop for each vendor and can forward provider cache-control hints transparently.

Ecosystem and tooling

GPT-5 has the largest third-party plugin and eval ecosystem. Every observability tool speaks its log format.

Claude Opus benefits from Anthropic’s prompt caching, which can drastically cut TTFT on repeated long system prompts by skipping prefill. You send a cache_control breakpoint; the provider reuses the KV cache.

Gemini 3 integrates with Vertex AI, giving you IAM, VPC, and regional controls out of the box. Its caching API is similar but keyed differently.

Limits and quota reality

Rate limits are the silent TTFT killer. A 429 doesn’t just fail—your retry loop adds seconds.

• GPT-5: per-org TPM and RPM limits, stricter on reasoning tier.
• Claude Opus: lower concurrent request caps; prefill-heavy calls consume more capacity.
• Gemini 3: generous free tier but production quotas require approval.

All three honor x-request-id for tracing. None guarantee TTFT; they guarantee eventual streaming. Set client timeouts to 30s for prefill-heavy Opus calls, 10s for Gemini.

Head-to-head comparison

Which to choose

Interactive chat where users watch the cursor. Gemini 3 wins on raw TTFT. If you need GPT-5’s reasoning, set reasoning_effort: low and accept slightly higher cost.

Long-system-prompt agents. Claude Opus with prompt caching is the pragmatic pick. Cache the static instructions; TTFT drops to the incremental part. GPT-5 works if you already use OpenAI tooling.

Cost-sensitive high-volume pipelines. Gemini 3 batch or GPT-5 mini-tier variants. Don’t measure TTFT here—use async batch and poll.

Fallback-critical production. Standardize on an OpenAI-compatible gateway and pin primary/secondary models. When Opus hits a concurrency limit, route to GPT-5 without code changes. The time to first token GPT-5 vs Claude Opus vs Gemini 3 becomes a routing decision, not a rewrite.

Pick based on where the spinner hurts most.