Ir al contenido principal
Español— Elegir un idioma
Menú

Primer flujo de trabajo: navegar e interactuar

Lección 4 de 14 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Ensamblar las piezas
  2. El gestor de acciones
  3. El bucle completo
  4. Lanzar el flujo de trabajo
  5. Una función reutilizable para el resto del curso
  6. Tres fallos que encontrarás
  7. Puntos clave

Lección reescrita el 3 de noviembre de 2026 basándose en la guía Computer use de OpenAI y en las recetas de integración de Computer use: el agente utiliza la herramienta computer de la API de Responses, un gestor de acciones modelado según la documentación (acciones agrupadas, keypress, scroll_x/scroll_y, trayectorias de drag) y el encadenamiento mediante previous_response_id, sustituyendo al código escrito para la API de Anthropic. Fuentes: Computer use · Recetas de integración.

Ensamblar las piezas

Ya tienes el bucle en mente y el entorno configurado. Ahora necesitas unir todo en un programa funcional: un agente que abra una enciclopedia en línea, busque un término, abra el primer resultado y te devuelva el título de la página alcanzada. El escenario parece modesto, pero involucra los gestos fundamentales —navegación, escritura, clic, lectura de información— y todo lo que construyas a continuación será simplemente una variación más larga de esto.

El gestor de acciones

El modelo decide, pero no ejecuta nada por sí mismo: devuelve una lista de acciones y tu código las traduce a gestos de Playwright, en orden. Esta función sigue el gestor publicado por OpenAI en sus recetas de integración, simplificado para un navegador.

import time

KEYS = {
    "ENTER": "Enter", "RETURN": "Enter", "ESC": "Escape", "ESCAPE": "Escape",
    "TAB": "Tab", "SPACE": "Space", "BACKSPACE": "Backspace", "DELETE": "Delete",
    "UP": "ArrowUp", "DOWN": "ArrowDown", "LEFT": "ArrowLeft", "RIGHT": "ArrowRight",
    "CTRL": "Control", "CONTROL": "Control", "SHIFT": "Shift", "ALT": "Alt",
    "CMD": "Meta", "META": "Meta",
}
BUTTONS = {"left": "left", "right": "right", "wheel": "middle"}

def execute_actions(page, actions):
    """Ejecuta las acciones de una computer_call en orden."""
    for action in actions:
        if action.type in ("click", "double_click", "drag", "move", "scroll") and getattr(action, "keys", None):
            raise ValueError("Acción de ratón con tecla modificadora: no gestionada aquí")
        match action.type:
            case "click":
                button = getattr(action, "button", "left")
                if button not in BUTTONS:  # atrás y adelante no existen en Playwright
                    raise ValueError(f"Botón no soportado: {button}")
                page.mouse.click(action.x, action.y, button=BUTTONS[button])
            case "double_click":
                page.mouse.dblclick(action.x, action.y)
            case "drag":
                points = [(p.x, p.y) for p in action.path]
                page.mouse.move(*points[0])
                page.mouse.down()
                for x, y in points[1:]:
                    page.mouse.move(x, y)
                page.mouse.up()
            case "move":
                page.mouse.move(action.x, action.y)
            case "scroll":
                page.mouse.move(action.x, action.y)
                page.mouse.wheel(action.scroll_x, action.scroll_y)
            case "keypress":
                page.keyboard.press("+".join(KEYS.get(k, k) for k in action.keys))
            case "type":
                page.keyboard.type(action.text)
            case "wait":
                time.sleep(2)
            case "screenshot":
                continue  # la captura se toma después de cada lote de acciones
            case _:
                raise ValueError(f"Acción no soportada: {action.type}")

Dos decisiones merecen una explicación. Los nombres de teclas y botones que devuelve el modelo (ENTER, CTRL, wheel…) no son los que espera Playwright (Enter, Control, middle…): las tablas de mapeo, extraídas de la documentación, salvan esta brecha, y los botones back y forward, que la API también puede solicitar, se rechazan al igual que en el gestor de OpenAI. Además, una acción desconocida lanza un error en lugar de ignorarse en silencio: es preferible detenerse en seco a tener un agente que cree que ha actuado cuando no lo ha hecho.

El bucle completo

El agente orquesta entonces el ciclo. La primera llamada envía la tarea; si solo contiene una solicitud de captura, simplemente devuelves la pantalla. Cada captura regresa al modelo como resultado de la llamada que la solicitó, referenciada por su call_id, y previous_response_id enlaza los turnos entre sí.

import base64

from openai import OpenAI
from playwright.sync_api import sync_playwright

client = OpenAI()
MODEL = "gpt-6.1-sol"
MAX_TURNS = 15

def launch_agent(task: str, start_url: str = "https://en.wikipedia.org"):
    """Lanza un agente de Computer Use para una tarea dada."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)  # False para observar
    page = browser.new_page(viewport={"width": 1280, "height": 720})
    page.goto(start_url)
    page.wait_for_load_state("networkidle")

    try:
        response = client.responses.create(
            model=MODEL, tools=[{"type": "computer"}], input=task,
        )
        for turn in range(MAX_TURNS):
            call = next((i for i in response.output if i.type == "computer_call"), None)
            if call is None:
                print(f"Tarea completada: {response.output_text}")
                return response.output_text

            if call.pending_safety_checks:  # ver lección 12
                raise RuntimeError("Comprobaciones de seguridad pendientes: se requiere intervención humana")
            for action in call.actions:
                print(f"  Acción: {action.type}")
            execute_actions(page, call.actions)
            screenshot = base64.b64encode(page.screenshot()).decode("utf-8")

            response = client.responses.create(
                model=MODEL,
                tools=[{"type": "computer"}],
                previous_response_id=response.id,
                input=[{
                    "type": "computer_call_output",
                    "call_id": call.call_id,
                    "output": {
                        "type": "computer_screenshot",
                        "image_url": f"data:image/png;base64,{screenshot}",
                        "detail": "original",
                    },
                }],
            )
        raise RuntimeError("Se ha alcanzado el número máximo de turnos: comprueba el estado de la página")
    finally:
        browser.close()
        pw.stop()

Tres salvaguardas ya están activas. MAX_TURNS acota el bucle: sin este límite, un agente desorientado consumiría tu presupuesto hasta agotarlo. Una llamada con comprobaciones de seguridad pendientes (pending_safety_checks) lo detiene todo, como en el ejemplo oficial de OpenAI: la lección 12 muestra cómo hacer que un humano las valide. Y la finalización normal se señala por la ausencia de una computer_call: el modelo ha dejado de actuar y te está respondiendo, por lo que recuperas el título de la página desde output_text.

Lanzar el flujo de trabajo

if __name__ == "__main__":
    launch_agent(
        "Busca 'Computer Use' en el motor de búsqueda de Wikipedia, "
        "abre el primer resultado y dame el título de la página. "
        "Usa la herramienta computer para actuar sobre la interfaz."
    )

Con headless=False, el espectáculo es instructivo: la ventana se abre, el clic aterriza en el campo de búsqueda, aparece el texto, se abre el primer enlace y el título regresa a tu consola. Observa su ejecución dos o tres veces antes de pasar a tareas más ambiciosas; verás exactamente dónde duda el agente y qué deben abordar tus instrucciones.

Una función reutilizable para el resto del curso

Las siguientes lecciones trabajan sobre una página ya abierta —tras un inicio de sesión, en medio de un flujo de trabajo—. Se basan en run_agent(task, page=page): el mismo bucle, extraído de launch_agent, con instructions opcionales devueltas en cada turno (la lección 5 explica por qué).

def run_agent(task: str, page, instructions: str | None = None, max_turns: int = MAX_TURNS) -> str:
    """Bucle de Computer Use en una página ya abierta; devuelve el mensaje final."""
    request = {"model": MODEL, "tools": [{"type": "computer"}]}
    if instructions:
        request["instructions"] = instructions  # para devolver en cada solicitud

    response = client.responses.create(**request, input=task)
    for turn in range(max_turns):
        call = next((i for i in response.output if i.type == "computer_call"), None)
        if call is None:
            return response.output_text
        if call.pending_safety_checks:
            raise RuntimeError("Comprobaciones de seguridad pendientes: se requiere intervención humana")

        execute_actions(page, call.actions)
        screenshot = base64.b64encode(page.screenshot()).decode("utf-8")
        response = client.responses.create(
            **request,
            previous_response_id=response.id,
            input=[{
                "type": "computer_call_output",
                "call_id": call.call_id,
                "output": {
                    "type": "computer_screenshot",
                    "image_url": f"data:image/png;base64,{screenshot}",
                    "detail": "original",
                },
            }],
        )
    raise RuntimeError("Se ha alcanzado el número máximo de turnos: comprueba el estado de la página")

Tres fallos que encontrarás

¿El agente hace clic sistemáticamente al lado de su objetivo? El culpable es casi siempre una discrepancia de escala entre la captura enviada y la página sobre la que se hace clic: captura redimensionada, zoom del navegador o pantalla de alta densidad. Las coordenadas del modelo se refieren a la imagen que recibió; si la reduces, convierte sus coordenadas en la dirección opuesta.

¿El agente da vueltas en círculo y repite el mismo gesto? El límite de turnos acabará deteniéndolo, pero es mejor detectar el bucle antes: si la misma captura regresa varias veces seguidas, el agente no está avanzando, e interrumpirlo te ahorra llamadas innecesarias.

¿El agente actúa sobre una página que aún está vacía? En un sitio pesado, page.goto() retorna antes de que termine el renderizado y la primera captura solo muestra un fondo blanco. Espera a la inactividad de la red antes de tomar la imagen:

page.goto(url)
page.wait_for_load_state("networkidle")

Puntos clave

  • Un agente de Computer Use combina un gestor de acciones, un bucle de control y un encadenamiento de respuestas
  • La primera llamada envía la tarea; cada captura regresa en un computer_call_output con el mismo call_id
  • El gestor ejecuta las acciones en orden y rechaza lo que no sabe hacer
  • Limita siempre el número de turnos, detente ante pending_safety_checks y usa headless=False durante el desarrollo
  • run_agent(task, page=page) reutiliza este bucle para una página ya abierta; esto es lo que usan las siguientes lecciones