Tiempo hasta el primer token (TTFT): qué es, cómo medirlo y qué nota tu usuario

¿Qué es el tiempo hasta el primer token?

El tiempo hasta el primer token (TTFT, por sus siglas en inglés) es lo que pasa desde que tu aplicación envía la petición hasta que recibe el primer token de la respuesta. La documentación de NVIDIA sobre medición de LLM lo define así y aclara que suele incluir tres cosas: el tiempo en cola, el prefill y la latencia de red.

El prefill es la fase en la que el modelo lee tu prompt completo (instrucciones de sistema, historial, documentos adjuntos) antes de poder escribir nada. Solo después empieza la decodificación, que genera la respuesta token a token. Por eso el TTFT depende tanto de lo largo que sea lo que mandas.

Con streaming, el TTFT es exactamente el rato que tu usuario mira una pantalla quieta. Una vez empieza a salir texto, la sensación de velocidad ya está ganada aunque el ritmo sea normal; sin streaming, en cambio, el usuario espera la respuesta entera y el TTFT deja de ser lo que importa.

TTFT, TPOT e ITL: las métricas de latencia de un LLM

Cuando se habla de la latencia de un LLM se mezclan cuatro números distintos. Conviene separarlos, porque cada uno se arregla con cosas diferentes:

Qué hace subir el TTFT

Casi todo el TTFT sale de cuatro sitios. Saber cuál pesa en tu caso te dice qué tocar:

Por qué el TTFT y los tokens por segundo tiran en direcciones opuestas

Un motor de inferencia sirve a muchos usuarios a la vez metiendo sus peticiones en lotes. Lotes más grandes sacan más tokens por segundo de la misma GPU, que es lo que abarata el token, pero cada petición comparte el cálculo con más vecinas.

vLLM, el motor de código abierto que se usa para servir buena parte de los modelos abiertos, lo explica con su presupuesto de tokens por lote: según su documentación, un presupuesto mayor mejora el TTFT porque cabe más prefill en cada paso, y uno menor mejora el ITL porque hay menos prefills frenando la decodificación de los demás. Su chunked prefill trocea los prompts largos para mezclarlos con esa decodificación y que un documento enorme no congele el resto de respuestas.

Otra pieza del mismo motor, el prefix caching, guarda el cálculo de los prefijos ya procesados. Si dos peticiones empiezan igual, que en un asistente es lo normal (mismo prompt de sistema, mismo historial), la segunda se salta esa parte del prefill.

Definiciones y comportamiento del motor según la documentación oficial de NVIDIA y de vLLM, consultada el 9 de noviembre de 2026. Fuentes: docs.nvidia.com/nim/benchmarking/llm/latest/metrics.html, docs.vllm.ai/en/latest/design/prefix_caching.html, docs.vllm.ai/en/latest/configuration/optimization.html

Cómo medir el TTFT de una API de LLM

La forma honesta de conocer el TTFT es medirlo desde tu lado, con streaming, porque así incluye todo lo que nota tu usuario: red, TLS, proxies, cola y prefill. Las métricas del lado del servidor suelen empezar a contar cuando la petición ya ha llegado al motor, y se dejan fuera parte del camino.

Este script usa el SDK oficial de OpenAI contra Token Factory. Funciona igual con cualquier API compatible: cambia la URL base, la variable de la clave y el modelo. Lanza una petición de calentamiento que no cuenta, después veinte medidas, e imprime el TTFT y el ritmo de cada una y sus percentiles.

# ttft.py: mide el TTFT y el ritmo de un modelo en streaming
# pip install openai
import math
import os
import time

from openai import OpenAI

client = OpenAI(
    base_url="https://api.gpuflow.ai/v1",
    api_key=os.environ["GPUFLOW_API_KEY"],
)

MODEL = "qwen-3.8-27b"
PROMPT = "Explica en cinco frases qué es la ventana de contexto de un modelo."
RUNS = 20


def one_request():
    start = time.perf_counter()
    first = None
    pieces = 0
    usage = None
    stream = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": PROMPT}],
        max_tokens=300,
        stream=True,
        stream_options={"include_usage": True},
    )
    for chunk in stream:
        if chunk.usage:
            usage = chunk.usage
        if not chunk.choices:
            continue
        delta = chunk.choices[0].delta
        # Los modelos de razonamiento emiten su pensamiento en otro campo.
        text = (
            delta.content
            or getattr(delta, "reasoning_content", None)
            or getattr(delta, "reasoning", None)
        )
        if text:
            if first is None:
                first = time.perf_counter()
            pieces += 1
    end = time.perf_counter()
    if first is None:
        raise RuntimeError("empty response")
    tokens = usage.completion_tokens if usage else pieces
    decode = end - first
    speed = (tokens - 1) / decode if tokens > 1 and decode > 0 else 0.0
    return first - start, speed


def percentile(values, p):
    ordered = sorted(values)
    rank = max(1, math.ceil(p / 100 * len(ordered)))
    return ordered[rank - 1]


one_request()  # calentamiento: abre la conexión y no cuenta
ttfts, speeds = [], []
for i in range(RUNS):
    ttft, speed = one_request()
    ttfts.append(ttft)
    speeds.append(speed)
    print(f"#{i + 1:<3} TTFT {ttft * 1000:7.0f} ms   {speed:6.1f} tokens/s")

print(f"TTFT      p50 {percentile(ttfts, 50) * 1000:.0f} ms   p95 {percentile(ttfts, 95) * 1000:.0f} ms")
print(f"tokens/s  p50 {percentile(speeds, 50):.1f}   p5 {percentile(speeds, 5):.1f}")

Los tokens por segundo que imprime son el ritmo de esa petición una vez empezó a responder (la inversa del TPOT), no la capacidad total del servidor. Si la respuesta no trae el recuento de tokens, el script cuenta los trozos que llegan, que es una aproximación.

Con modelos de razonamiento el script cuenta como primer token también el primero del pensamiento. Si tu interfaz solo enseña la respuesta final, mide el primer token de contenido: quita las dos líneas de getattr.

Cinco reglas para que la medida sirva

1. 1Usa tu prompt real, con su longitud real. Un «hola» mide la red, no tu caso.
2. 2Mide desde donde están tus usuarios o tu servidor, no desde tu portátil en otra red.
3. 3Fija max_tokens y el modelo, y no cambies dos cosas entre una tanda y otra.
4. 4Repite a distintas horas: la cola cambia con la carga y el TTFT con ella.
5. 5Prueba también con el contexto largo que tendrá tu conversación en el turno veinte, no solo en el primero.

Percentiles p50 y p95: por qué la media engaña

La media de veinte medidas esconde lo que más molesta: la petición que tarda el triple. Por eso la latencia se cuenta en percentiles. El p50 (la mediana) es lo que vive la mitad de tus usuarios; el p95 es el valor que solo supera una de cada veinte peticiones.

El p95 es el que hay que vigilar, porque un usuario hace muchas peticiones en una sesión y acaba topando con la cola lenta. Con veinte medidas, el p95 es prácticamente tu segunda peor; para afinarlo hacen falta cientos de muestras, repartidas en el tiempo.

Cuando compares proveedores, compara el mismo percentil, con el mismo prompt y en la misma franja horaria. Una cifra sin percentil, sin longitud de prompt y sin decir desde dónde se midió no se puede comparar con nada.

¿Qué TTFT es bueno para tu producto?

Depende de lo que hace tu usuario mientras espera. En un chat con streaming, el TTFT es casi toda la sensación de rapidez. En un agente de voz se suma al reconocimiento de voz y a la síntesis, así que el presupuesto de cada pieza es menor. En un agente que encadena diez llamadas, lo que pesa es la latencia total de cada paso. En un proceso nocturno por lotes, el TTFT da igual y mandan los tokens por segundo y el precio.

Lo útil es fijar tu objetivo de p95 a partir de tu interfaz, medirlo con el script y repetir la medida cuando cambies de modelo, de longitud de prompt o de proveedor.

Cómo funciona esto en GPU Flow

No publicamos una cifra de TTFT. Para dar un número que valga para tu caso haría falta medirlo con tráfico real, desde fuera y con prompts como los tuyos, y no lo hemos hecho todavía: un número sin esa medición sería un dato de folleto. Por eso te damos el script.

Lo que sí tenemos montado, y que juega a favor del TTFT:

Relacionados

• Migra de la API de OpenAI a una alternativa open source en 15 minutos (con código)Migra del SDK de OpenAI a GPU Flow en cinco pasos: cambia la URL base, elige el modelo equivalente y conserva streaming, herramientas y razonamiento.
• Alternativa a la API de OpenAI: GPU Flow frente a OpenAIPrecios por millón de tokens, audio, migración y cuándo quedarse en OpenAI, con sus precios consultados en su web.