La ejecución duradera es la técnica que hace que un agente de IA termine su tarea aunque el proceso se caiga, se reinicie o choque con un límite de la API a mitad de camino. Temporal[1] es la plataforma de código abierto que más ha popularizado este modelo, y desde 2026 tiene integraciones oficiales con los SDK de agentes de OpenAI y de Vercel. En esta guía verás por qué los agentes largos fallan a mitad, qué es la ejecución duradera, cómo Temporal separa el trabajo en workflows y actividades, un agente que sobrevive a reinicios y en qué se diferencia de una cola de mensajes normal. La misma explicación está disponible en inglés.

Puntos clave

  • La ejecución duradera garantiza, en palabras de la documentación de Temporal, que una función «se ejecute hasta el final, tarde minutos, horas, días, semanas o incluso años», recuperándose sola de los fallos.
  • Temporal es software libre con licencia MIT; su repositorio principal supera las 21 700 estrellas en GitHub y va por la versión v1.31.2, publicada el 8 de julio de 2026.
  • El modelo separa dos piezas: los workflows (la lógica de orquestación, determinista y reanudable) y las actividades (cualquier llamada externa: al modelo, a una herramienta o a una API), que Temporal reintenta sola cuando fallan.
  • La integración oficial con el OpenAI Agents SDK (temporalio.contrib.openai_agents) pasó a disponibilidad general el 23 de marzo de 2026, tras un adelanto público en julio de 2025; se instala con pip install "temporalio[openai-agents]" y necesita Python 3.10 o superior.
  • Convierte cada agente en un proceso a prueba de caídas sin reescribir tu código: envuelves la lógica del agente en un workflow y las llamadas al modelo corren como actividades reintentables.

¿Por qué los agentes largos fallan a mitad?

Un agente de IA no es una sola llamada al modelo: es un bucle. El modelo razona, decide invocar una herramienta, lee el resultado, vuelve a razonar y repite el ciclo hasta terminar. Cada vuelta toca el mundo exterior, y ahí está el problema: las herramientas llaman a APIs que a veces fallan, y los modelos chocan con límites de tasa que obligan a reintentar. Cuanto más largo es el agente, más caro resulta empezar la tarea de cero.

Imagina un agente que procesa una devolución: consulta el pedido, valida la garantía, emite el reembolso y notifica al cliente. Si el proceso se cae después de emitir el reembolso pero antes de notificar, ¿qué pasa al reiniciar? Sin protección, o pierdes el trabajo hecho o lo repites y reembolsas dos veces. La documentación de Temporal lo resume así: los modelos «pueden encontrarse con límites de tasa que exigen reintentos», y cuanto más dura el agente, más duele reiniciarlo.

La respuesta habitual (guardar el estado en una base de datos, montar colas, escribir máquinas de estado a mano) funciona, pero llena tu código de fontanería que no tiene nada que ver con la lógica del agente. Es justo el trabajo pesado que la ejecución duradera te quita de encima. Este problema se agrava cuando el agente ya está desplegado en producción, donde un reinicio del contenedor no puede traducirse en una tarea perdida.

¿Qué es la ejecución duradera?

La ejecución duradera es un modelo de programación en el que, una vez arranca, la función principal de tu aplicación llega hasta el final pase lo que pase por debajo. Si el proceso se cae, la máquina se reinicia o la red se cae, el sistema reconstruye el estado exacto en el que estaba y continúa desde ahí, sin repetir el trabajo ya hecho.

El truco está en cómo se consigue esa memoria. Temporal registra cada paso que da tu programa en un historial de eventos durable. Cuando algo falla y el proceso vuelve a levantarse, Temporal reproduce ese historial para reconstruir el estado en memoria y retoma la ejecución justo donde se quedó. Por eso los pasos deterministas (tu lógica) se separan de los no deterministas (las llamadas externas): los primeros se pueden reproducir sin efectos secundarios, los segundos se registran una sola vez.

El equipo de Temporal lo describe con una frase que resume su propuesta: «Con Temporal, tú programas el camino feliz y Temporal se encarga del manejo de errores por ti». En la práctica, esto significa que dejas de escribir bloques try/except con reintentos manuales, temporizadores y comprobaciones de idempotencia: el sistema los aporta de serie.

Temporal: workflows y actividades

Todo en Temporal gira en torno a dos abstracciones. Un workflow es la función que contiene tu lógica de orquestación; debe ser determinista, porque Temporal la reproduce para recuperar el estado. Una actividad es cualquier operación que toca el mundo exterior y que, por tanto, no es determinista: una llamada al modelo de lenguaje, una consulta a una API, una escritura en la base de datos. Temporal ejecuta las actividades una sola vez, guarda su resultado y las reintenta con la política que definas si fallan.

Aplicado a un agente, el reparto es natural: la lógica del agente (el bucle de razonamiento) vive en el workflow, y cada llamada al modelo o a una herramienta se convierte en una actividad reintentable. En Python, un workflow se marca con el decorador @workflow.defn y una actividad con @activity.defn. Este ejemplo mínimo define una herramienta del tiempo como actividad durable:

from dataclasses import dataclass
from datetime import timedelta
from temporalio import activity, workflow
from temporalio.contrib import openai_agents
from agents import Agent, Runner

@dataclass
class Tiempo:
    ciudad: str
    rango_temp: str
    condiciones: str

@activity.defn
async def consultar_tiempo(ciudad: str) -> Tiempo:
    """Consulta el tiempo de una ciudad (aqui, un valor fijo)."""
    return Tiempo(ciudad=ciudad, rango_temp="14-20C", condiciones="Soleado")

@workflow.defn
class AgenteDelTiempo:
    @workflow.run
    async def run(self, pregunta: str) -> str:
        agente = Agent(
            name="Asistente del tiempo",
            instructions="Eres un agente del tiempo util y conciso.",
            tools=[
                openai_agents.workflow.activity_as_tool(
                    consultar_tiempo,
                    start_to_close_timeout=timedelta(seconds=10),
                )
            ],
        )
        resultado = await Runner.run(starting_agent=agente, input=pregunta)
        return resultado.final_output

La pieza clave es activity_as_tool: coge una actividad de Temporal y la presenta al agente como una herramienta más del OpenAI Agents SDK. El modelo decide cuándo invocarla, pero por debajo se ejecuta con las garantías de durabilidad y reintento de Temporal. La llamada al propio modelo no la escribes tú: el OpenAIAgentsPlugin registra automáticamente una actividad que envuelve cada invocación del modelo.

Un agente que sobrevive a reinicios

Para que ese agente se ejecute con durabilidad hace falta un worker, el proceso que aloja workflows y actividades y se conecta al servidor de Temporal. Aquí es donde se activa el plugin de OpenAI:

import asyncio
from datetime import timedelta

from temporalio.client import Client
from temporalio.worker import Worker
from temporalio.contrib.openai_agents import (
    OpenAIAgentsPlugin,
    ModelActivityParameters,
)
from agente_tiempo import AgenteDelTiempo, consultar_tiempo

async def main():
    cliente = await Client.connect(
        "localhost:7233",
        plugins=[
            OpenAIAgentsPlugin(
                model_params=ModelActivityParameters(
                    start_to_close_timeout=timedelta(seconds=30)
                )
            )
        ],
    )
    worker = Worker(
        cliente,
        task_queue="cola-agente-tiempo",
        workflows=[AgenteDelTiempo],
        activities=[consultar_tiempo],
    )
    await worker.run()

asyncio.run(main())

Ahora la prueba de fuego: si matas este proceso mientras el agente espera la respuesta del modelo y lo vuelves a arrancar, el workflow no empieza de cero. Temporal reproduce su historial, recupera el estado y continúa desde el último paso confirmado, sin repetir la llamada que ya se había completado. Ese es todo el argumento de la ejecución duradera: código normal que sobrevive a reinicios sin fontanería adicional.

El mismo patrón habilita agentes de larga duración con humano en el bucle: un workflow puede quedarse esperando una aprobación durante días sin consumir recursos, porque su estado vive en el historial y no en la memoria del proceso. Si quieres una base sin dependencia de OpenAI, la integración con el AI SDK de Vercel sigue la misma idea en TypeScript: usas temporalProvider.languageModel() en lugar de openai() y cada generateText() se envuelve en una actividad de forma transparente. Y si prefieres construir el agente a mano, el enfoque combina bien con el SDK de Anthropic o con grafos como LangGraph.

Temporal frente a colas simples

Es tentador pensar que una cola de mensajes (RabbitMQ, SQS, Redis) resuelve lo mismo, y para tareas de un solo paso a menudo basta. La diferencia aparece cuando el agente encadena decisiones. Una cola te da reintentos por mensaje, pero no conoce el flujo: no sabe que ya emitiste el reembolso y solo falta notificar. Tú tienes que reconstruir ese estado a mano, con tablas, banderas de idempotencia y máquinas de estado que crecen sin control.

Temporal invierte el planteamiento: el flujo completo es el código, y el estado se guarda solo. No gestionas colas ni escribes máquinas de estado; escribes una función y el sistema la hace durable. A cambio, introduces un servidor de Temporal en tu arquitectura y aceptas la restricción de que los workflows sean deterministas. Para un agente de un solo paso, una cola es más simple. Para un agente que razona, llama a herramientas y puede tardar horas o días, Temporal elimina justo la complejidad que una cola te deja encima de la mesa. En la conferencia Replay 2026, Temporal reforzó esta apuesta anunciando Serverless Workers e integraciones con Google ADK además del OpenAI Agents SDK.

Preguntas frecuentes

¿Necesito un servidor de Temporal para usar la ejecución duradera?

Sí. Temporal es un sistema cliente-servidor: tu worker se conecta a un servidor que guarda el historial de eventos y coordina los reintentos. Puedes autoalojarlo con Docker para desarrollo (temporal server start-dev) o usar Temporal Cloud, el servicio gestionado. Sin ese servidor no hay historial que reproducir, así que la durabilidad no existe; es la contrapartida de no tener que escribir tú la persistencia del estado.

¿Sirve Temporal solo con OpenAI o con cualquier modelo?

Sirve con cualquiera. La integración con el OpenAI Agents SDK es la más pulida y llegó a disponibilidad general el 23 de marzo de 2026, pero el OpenAI Agents SDK admite modelos de muchos proveedores. Además, existe la integración con el AI SDK de Vercel para TypeScript y, en el fondo, siempre puedes envolver cualquier llamada a un modelo (Anthropic, Gemini, un modelo propio) en una actividad de Temporal a mano, sin depender de ninguna integración.

¿Qué diferencia hay entre un workflow y una actividad?

Un workflow contiene la lógica de orquestación y debe ser determinista, porque Temporal lo reproduce para recuperar el estado tras un fallo. Una actividad es cualquier operación no determinista o con efectos secundarios (llamar al modelo, a una API o a la base de datos) y se ejecuta una sola vez, con reintentos automáticos. La regla práctica: si toca el mundo exterior, va en una actividad; si solo coordina, va en el workflow.

Conclusión

La ejecución duradera con Temporal convierte un agente frágil en uno a prueba de caídas sin que tengas que escribir la persistencia del estado, los reintentos ni las máquinas de estado. La idea es simple: tu lógica vive en un workflow determinista y reanudable, y cada llamada al modelo o a una herramienta corre como una actividad reintentable. Con la integración temporalio.contrib.openai_agents ya en disponibilidad general y Temporal en su versión v1.31.2, el patrón puede llevarse a producción con garantías. El siguiente paso es instalarlo con pip install "temporalio[openai-agents]", levantar un servidor de desarrollo y envolver tu primer agente en un workflow para verlo sobrevivir a un reinicio.

Fuentes: [1] Documentación oficial de Temporal[2], [2] Integración del OpenAI Agents SDK en GitHub[3], [3] Anuncio de disponibilidad general en el blog de Temporal[4], [4] Paquete temporalio en PyPI[5].

Visitas: 1

Fuentes

  1. Temporal
  2. Documentación oficial de Temporal
  3. Integración del OpenAI Agents SDK en GitHub
  4. Anuncio de disponibilidad general en el blog de Temporal
  5. Paquete temporalio en PyPI

Ruta: Agentes de IA en producción: evaluación y fiabilidad