Tu agente IA tarda 12 segundos. Cómo bajarlo a 2.

Construiste el agente. Funciona. Los tests pasan. Lo pones en producción y el primer feedback que recibes es: "esto tarda una eternidad."

No es un fallo lógico. El agente hace exactamente lo que tiene que hacer. El problema es que lo hace en 12 segundos cuando debería hacerlo en 2.

Esto le pasa a todos los equipos que pasan de "prototipo que funciona" a "producto que la gente usa". Y tiene causas concretas con soluciones concretas.

Por qué tu agente tarda lo que tarda

Antes de optimizar, hay que saber dónde se va el tiempo. En la mayoría de pipelines LLM mal configurados, la latencia viene de cuatro sitios:

1. El modelo genera todo antes de mostrar nada — sin streaming
2. Los tool calls se ejecutan en serie — aunque no dependen entre sí
3. Cada query idéntica va al modelo — sin ningún tipo de caché
4. Usas el mismo modelo para todo — tanto para "¿qué tiempo hace?" como para razonar sobre un contrato de 40 páginas

Vamos una por una.

Fix 1: Streaming — la percepción importa tanto como la realidad

Sin streaming, el usuario ve una pantalla en blanco durante 8 segundos y luego aparece todo el texto de golpe. Con streaming, empieza a leer en 400ms aunque el modelo tarde lo mismo en terminar.

La latencia real no cambia. La latencia percibida cae a la décima parte.

// Sin streaming — el usuario espera hasta el final
const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages,
});
return response.choices[0].message.content;

// Con streaming — el usuario lee mientras el modelo genera
const stream = await openai.chat.completions.create({
  model: "gpt-4o",
  messages,
  stream: true,
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content ?? "";
  process.stdout.write(delta); // o res.write(delta) en tu API
}

Si tu agente no tiene streaming activo hoy, es la mejora con mayor impacto por líneas de código escritas.

Fix 2: Tool calls en paralelo, no en serie

Este es el error más común y el que más tiempo mata.

Imagina un agente que necesita: (1) consultar el historial del cliente, (2) obtener el inventario disponible, y (3) revisar el precio actual. Si lo hace en serie, esperas la suma de los tres. Si lo hace en paralelo, esperas el más lento de los tres.

// ❌ En serie — 3s + 2s + 1.5s = 6.5 segundos
const historial = await getClientHistory(clientId);
const inventario = await getInventory(productId);
const precio = await getCurrentPrice(productId);

// ✅ En paralelo — max(3s, 2s, 1.5s) = 3 segundos
const [historial, inventario, precio] = await Promise.all([
  getClientHistory(clientId),
  getInventory(productId),
  getCurrentPrice(productId),
]);

La mayoría de agentes que usan frameworks como LangChain o LangGraph ejecutan los tool calls en serie por defecto. Tienes que activar explícitamente la paralelización o implementarla tú mismo.

Un buen servicio de integración de agentes IA incluye la revisión de este tipo de patrones desde el principio, no como optimización a posteriori.

Fix 3: Caché semántico para queries repetidas

No todas las queries a tu agente son únicas. En la mayoría de sistemas de soporte o consulta, el 60-70% de preguntas son variaciones de las mismas 20 preguntas base.

El caché semántico no busca strings idénticos: busca significado similar. "¿Cuánto cuesta el plan básico?", "precio del plan básico" y "qué vale el básico" son la misma query. Con caché semántico, solo llamas al modelo una vez.

import { RedisSemanticCache } from "@langchain/community/caches/ioredis";

const cache = new RedisSemanticCache({
  redisUrl: process.env.REDIS_URL,
  embeddingModel: embeddings,
  similarityThreshold: 0.92, // ajusta según tu caso de uso
  ttl: 3600, // 1 hora
});

// La librería gestiona el caché automáticamente
const llm = new ChatOpenAI({
  model: "gpt-4o",
  cache,
});

En sistemas con mucho volumen, esto no solo reduce latencia: reduce coste de API en un 40-60%.

Fix 4: Routing por complejidad de modelo

No necesitas GPT-4o para responder "¿Cuál es el horario de atención?". Pero sí lo necesitas para analizar un contrato legal o razonar sobre datos financieros complejos.

El routing por complejidad dirige cada query al modelo más apropiado:

async function routeToModel(query: string, context: Context) {
  const complexity = await assessComplexity(query);
  
  if (complexity === "simple") {
    // Respuesta rápida y barata — 200ms, $0.0001
    return await callModel("gpt-4o-mini", query, context);
  } else if (complexity === "medium") {
    // Balance velocidad/razonamiento — 800ms, $0.001
    return await callModel("gpt-4o", query, context);
  } else {
    // Razonamiento profundo cuando lo necesitas — 3-4s, $0.01+
    return await callModel("o3-mini", query, context);
  }
}

Esta arquitectura tiene más complejidad de implementación, pero en sistemas de producción con volumen real es lo que separa un agente de $500/mes en API de uno de $50/mes con mejor UX.

Si estás diseñando la arquitectura de tu agente desde cero, en DAILYMP llevamos estas decisiones integradas desde el día uno, no como deuda técnica que resolver después.

El orden correcto de implementación

No hagas todo a la vez. El orden que da más retorno por esfuerzo:

1. Streaming — una tarde de trabajo, mejora inmediata visible
2. Paralelizar tool calls — revisar tu código existente, horas no días
3. Caché semántico — necesitas Redis o similar, un par de días
4. Routing por complejidad — requiere diseño, implementar en sprint dedicado

Con solo los dos primeros, la mayoría de agentes pasan de 10-12 segundos a 3-4 segundos. Con los cuatro, sueles llegar a ese rango de 1-2 segundos que hace que un agente se sienta "rápido".

El problema de optimizar tarde

El error que veo repetirse es construir el agente completo sin pensar en latencia, y luego intentar optimizar encima de una arquitectura que no fue diseñada para ello.

El caché semántico necesita que tus queries pasen por un punto central. La paralelización necesita que tus tool calls estén desacoplados. El routing necesita que tu arquitectura permita intercambiar modelos sin reescribir la lógica.

Si construyes sin pensar en esto desde el principio, optimizar después cuesta diez veces más.

---

¿Tienes un agente en producción que va lento, o estás diseñando uno y quieres hacerlo bien desde el principio? Hablamos en WhatsApp — en 30 minutos vemos qué está fallando y qué haría yo en tu caso.