Automatiza flujos de trabajo de varios pasos
En esta página
Lección actualizada el 3 de noviembre de 2026 según las directrices de integración de Computer Use de OpenAI: el agente ya no gestiona el inicio de sesión; la validación de comandos y las ramas que comprometen al usuario (reseñas, nuevos pedidos) requieren confirmación humana; el orquestador ahora verifica el criterio
success_text_containsque antes ignoraba, marca los pasos fallidos en lugar de omitirlos y nunca vuelve a ejecutar un paso que crea datos. Fuente: Confirmation and consent.
Orquestación de tareas complejas
Los flujos de trabajo reales rara vez consisten en una única acción. Rellenar un CRM implica navegar entre páginas, buscar un contacto, actualizar su información y, a continuación, crear una oportunidad: cuatro operaciones encadenadas, cada una de las cuales puede fallar por razones distintas. Entregar todo este bloque a un agente en un único prompt funciona a veces, pero nunca sabrás dónde ha fallado. Esta lección te enseña a estructurar estas automatizaciones de varios pasos para que cada eslabón sea observable y reproducible.
Arquitectura basada en pasos
Empieza dividiendo el flujo de trabajo en pasos atómicos, cada uno con un objetivo claro y un criterio de éxito. Este criterio es lo que distingue una lista de tareas de un flujo de trabajo real: sin él, tu orquestador no puede saber si el agente ha tenido éxito o se ha detenido en una página de error. En el ejemplo siguiente, la apertura del módulo se verifica mediante la URL, y la búsqueda mediante la presencia del nombre del contacto en pantalla. El inicio de sesión no se incluye aquí: tu código lo gestionó previamente, sin exponer la contraseña al modelo (lección 8). El paso final tiene "retry": False porque crea datos: volver a ejecutarlo tras un fallo parcial podría generar un duplicado.
workflow = [
{
"name": "open_contacts",
"task": "Abre el módulo Contactos en el CRM.",
"success_url_contains": "/contacts",
},
{
"name": "search_contact",
"task": "Busca el contacto 'Jean Dupont' en la barra de búsqueda.",
"success_text_contains": "Jean Dupont",
},
{
"name": "update_record",
"task": "Abre el perfil de Jean Dupont y actualiza su número de teléfono: 06 98 76 54 32.",
},
{
"name": "create_opportunity",
"task": "Crea una oportunidad: 'Migración a la nube T2 2026', importe 50000 EUR, probabilidad 60%.",
"retry": False, # paso no reproducible: crea datos
},
]
El orquestador
Ahora necesitas ejecutar esta lista. El orquestador recorre los pasos secuencialmente, envolviendo cada uno en un bucle de reintentos: un paso que lanza una excepción o no cumple su criterio de éxito se reintenta hasta max_retries veces, a menos que esté marcado como no reproducible. Este detalle es crucial en producción, porque muchos fallos de agentes visuales son transitorios: una página lenta, una renderización incompleta en el momento de la captura. Un paso que falla definitivamente detiene el flujo de trabajo, ya que los pasos posteriores dependen de él. Por último, el orquestador devuelve un registro estructurado que indica, para cada paso, su estado y el número de intentos consumidos: tu primera herramienta de diagnóstico.
def run_workflow(workflow: list, page, max_retries: int = 2):
"""Ejecuta un flujo de trabajo de varios pasos con reintentos."""
results = []
for step in workflow:
step_name = step["name"]
print(f"\n--- Paso: {step_name} ---")
attempts = max_retries + 1 if step.get("retry", True) else 1
error = "criterio de éxito no cumplido"
for attempt in range(attempts):
try:
run_agent(step["task"], page=page)
# Comprobaciones opcionales: URL, luego texto visible
url_check = step.get("success_url_contains")
if url_check and url_check not in page.url:
print(" URL esperada no encontrada")
continue
text_check = step.get("success_text_contains")
if text_check and text_check not in page.locator("body").inner_text():
print(" Texto esperado no encontrado")
continue
print(f" Éxito (intento {attempt + 1})")
results.append({"step": step_name, "status": "success", "attempts": attempt + 1})
break
except Exception as e:
print(f" Error: {e}")
error = str(e)
else:
# Ningún intento tuvo éxito: los pasos posteriores dependen de este
results.append({"step": step_name, "status": "failed", "error": error})
break
return results
Paso de datos entre pasos
A menudo, un paso produce datos necesarios para el siguiente: el precio leído en una página del carrito debe verificarse en el paso de pago; el número de caso creado en el paso 2 sirve de referencia en el paso 5. Un contexto compartido resuelve esta necesidad sin convertir tu código en un enredo de variables globales. El ejemplo siguiente se detiene intencionadamente antes del pago: OpenAI clasifica la confirmación de una transacción financiera como una acción que requiere validación del usuario en el momento de la ejecución. La clase siguiente almacena pares clave-valor y expone un método inject que sustituye los marcadores {key} en una plantilla de prompt, lo que te permite escribir tus tareas como plantillas parametrizadas.
class WorkflowContext:
"""Almacena datos compartidos entre pasos."""
def __init__(self):
self.data = {}
def set(self, key: str, value):
self.data[key] = value
def get(self, key: str, default=None):
return self.data.get(key, default)
def inject(self, template: str) -> str:
"""Sustituye las variables {key} en la plantilla."""
task = template
for key, value in self.data.items():
task = task.replace("{" + key + "}", str(value))
return task
# Ejemplo de uso
ctx = WorkflowContext()
# Paso 1: el agente lee un precio
extracted_price = run_agent(
"Lee el precio total mostrado y devuelve solo el número.",
page=page
)
ctx.set("price", extracted_price.strip())
# Paso 2: el agente verifica, sin validar nada
verdict = run_agent(ctx.inject(
"El importe esperado es {price} EUR. Compáralo con el total de la página de pago "
"y responde solo OK o MISMATCH. No valides nada."
), page=page)
# Paso 3: una transacción se confirma en el momento de la acción, por un humano
if verdict.strip() == "OK":
if input(f"¿Confirmar pedido de {ctx.get('price')} EUR? [y/N] ").strip().lower() == "y":
run_agent("Haz clic en el botón de confirmación del pedido.", page=page)
Flujos de trabajo condicionales
Las secuencias lineales alcanzan rápidamente sus límites, porque el siguiente paso puede depender del resultado anterior. El patrón que debes recordar es este: pide primero al agente que lea un estado obligándole a responder con un valor de un conjunto cerrado y, a continuación, ramifica en Python. Para el seguimiento de pedidos, un estado «processing» lleva al seguimiento del paquete, «delivered» a obtener la fecha de entrega y «canceled» a obtener el motivo. Las restricciones de formato en el prompt son esenciales: sin ellas, el agente devuelve una frase que tus comparaciones omitirán con frecuencia. Las tres ramas permanecen como solo lectura: publicar una reseña o volver a pedir comprometería al usuario y requeriría su confirmación.
def conditional_workflow(page):
"""Flujo de trabajo con ramificación condicional."""
# Paso 1: Leer estado
status = run_agent(
"Lee el estado del pedido. "
"Devuelve solo: processing, delivered o canceled.",
page=page
)
# Ramificación basada en el resultado
match status.strip().lower():
case "processing":
return run_agent("Haz clic en 'Track package' y anota la etapa mostrada.", page=page)
case "delivered":
return run_agent("Anota la fecha de entrega mostrada.", page=page)
case "canceled":
return run_agent("Anota el motivo de cancelación mostrado.", page=page)
case _:
raise ValueError(f"Estado inesperado: {status!r}")
Paralelización
Cuando las tareas son independientes, no es necesario procesarlas secuencialmente. Extraer datos de tres fichas de producto lleva mucho menos tiempo si tres agentes trabajan simultáneamente, cada uno en su propia pestaña. La versión asíncrona de Playwright y asyncio.gather son suficientes: una corrutina por URL, un new_page por corrutina y un cierre sistemático de la página para evitar acumular pestañas en memoria. run_agent_async es el bucle de la lección 4 reescrito con el cliente AsyncOpenAI y la API asíncrona de Playwright: la misma lógica, con await antes de cada llamada. Ten en cuenta que el paralelismo también multiplica tu throughput de llamadas a la API, aumentando el riesgo de alcanzar tus límites de tasa (lección 11), y tu carga sobre el sitio objetivo: tres pestañas pasan desapercibidas, cincuenta mucho menos.
import asyncio
from playwright.async_api import async_playwright
async def parallel_extraction(urls: list[str]):
"""Extrae datos de varias páginas en paralelo."""
async with async_playwright() as pw:
browser = await pw.chromium.launch(headless=True)
async def extract_one(url: str):
page = await browser.new_page(
viewport={"width": 1280, "height": 720}
)
try:
await page.goto(url)
result = await run_agent_async(
"Extrae el título y el precio del producto.", page=page
)
finally:
await page.close()
return {"url": url, "data": result}
results = await asyncio.gather(
*[extract_one(url) for url in urls]
)
return results
# Ejecución
urls = [
"https://shop.example.com/product/1",
"https://shop.example.com/product/2",
"https://shop.example.com/product/3",
]
data = asyncio.run(parallel_extraction(urls))
Puntos clave
- Divide los flujos de trabajo en pasos atómicos con criterios de éxito explícitos
- Vuelve a ejecutar automáticamente los pasos que pueden reintentarse de forma segura, nunca los que crean datos
- Usa un contexto compartido para pasar datos entre pasos
- Los flujos de trabajo condicionales se adaptan al contenido de la página; las ramas que comprometen al usuario requieren su confirmación
- Paraleliza tareas independientes para ahorrar tiempo