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

Arquitectura: capturas de pantalla, acciones y el bucle de interacción

Lección 2 de 14 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. El bucle percepción-acción
  2. El punto de partida: la captura de pantalla
  3. Análisis y decisión
  4. El repertorio de acciones
  5. El flujo completo
  6. Cuánto cuesta un turno del bucle
  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: este curso dependía anteriormente de la API de Anthropic (import anthropic, herramienta computer_20241022). Ahora utiliza la herramienta computer de la API de Responses de OpenAI, con las acciones agrupadas en un computer_call y las capturas de pantalla devueltas mediante computer_call_output. Hemos eliminado los recuentos de tokens y las estimaciones de duración sin fuente de la versión anterior. Fuentes: Computer use · Recetas de integración.

El bucle percepción-acción

Toda la arquitectura de Computer Use se reduce a un único ciclo: observar → decidir → actuar → observar. Mientras este ciclo no quede claro en tu mente, tus automatizaciones serán erráticas; en cuanto lo entiendas, el resto es solo fontanería.

La diferencia con un script de Selenium radica en dónde reside el conocimiento. Selenium ejecuta ciegamente una secuencia predeterminada: haz clic aquí, luego allí, luego escribe esto. Computer Use elige el siguiente paso solo después de ver el resultado del anterior. Aparece una ventana emergente, una página tarda más en cargar o la etiqueta de un botón cambia de la noche a la mañana: en los tres casos, el modelo ve la situación real y se ajusta, mientras que el script sigue recitando al vacío.

Con la herramienta computer de OpenAI, el intercambio ocurre en tres pasos: envías la tarea, ejecutas las acciones que devuelve el modelo y, a continuación, le envías de vuelta una captura de pantalla. Tu aplicación maneja el ratón y el teclado; el modelo solo toma las decisiones.

El punto de partida: la captura de pantalla

Cada turno se basa en una imagen del estado actual de la pantalla. Esta captura de pantalla proviene de un navegador controlado por Playwright —el caso más común para la automatización web—, de un escritorio virtual al automatizar una aplicación de escritorio o de un contenedor Docker que aísla al agente. OpenAI recomienda utilizar en todos los casos un navegador aislado o una máquina virtual.

import base64

def capture_screen(page) -> str:
    """Captura la pantalla con Playwright y devuelve la imagen PNG en base64."""
    return base64.b64encode(page.screenshot()).decode("utf-8")

La captura de pantalla se envía al modelo como una URL de datos PNG. Cuenta como una entrada de imagen, por lo que afecta al coste de cada turno: el tamaño de la ventana que captures es un parámetro de diseño real.

Análisis y decisión

El modelo recibe la tarea, el historial de la conversación y la última captura de pantalla. Su respuesta no es una frase, sino un elemento computer_call, que contiene una lista ordenada de acciones a ejecutar. He aquí un ejemplo de la documentación de OpenAI que selecciona un campo de búsqueda y luego escribe una palabra:

{
  "type": "computer_call",
  "call_id": "call_002",
  "actions": [
    { "type": "click", "button": "left", "x": 405, "y": 157 },
    { "type": "type", "text": "penguin" }
  ],
  "status": "completed"
}

Dos detalles son importantes. La primera llamada podría contener solo una acción screenshot: el modelo está pidiendo ver la pantalla antes de actuar, y tú devuelves una captura de pantalla sin cambiar nada. Además, status: "completed" significa que el modelo ha terminado de generar la llamada, no que las acciones se hayan realizado: ejecutarlas depende de ti.

El repertorio de acciones

El vocabulario disponible para el modelo es intencionadamente limitado; combinados, estos primitivos cubren la mayor parte de lo que un humano hace con el ratón y el teclado.

AcciónDescripciónCampos
clickHacer clic en una posiciónx, y, button (left, right, wheel, back, forward)
double_clickDoble clicx, y
dragArrastrar a lo largo de una trayectoriapath (lista de puntos)
moveMover el punterox, y
scrollDesplazarx, y, scroll_x, scroll_y
keypressTecla o combinaciónkeys (p. ej., ["CTRL", "A"])
typeEscribir textotext
waitDejar que la página cargue—
screenshotSolicitar una nueva captura de pantalla—

El flujo completo

Juntos, estos elementos crean el siguiente bucle, modelado según la documentación de OpenAI. Mientras la respuesta contenga un computer_call, ejecutas sus acciones, capturas la pantalla y devuelves la captura en un computer_call_output que reutiliza el mismo call_id; previous_response_id vincula cada turno con el anterior.

from openai import OpenAI

client = OpenAI()

def computer_use_loop(page, task: str):
    """Bucle de Computer Use con la herramienta computer de la API de Responses."""
    response = client.responses.create(
        model="gpt-6.1-sol",
        tools=[{"type": "computer"}],
        input=task,
    )

    while True:
        call = next(
            (item for item in response.output if item.type == "computer_call"),
            None,
        )
        if call is None:
            return response.output_text  # no hay más acciones solicitadas: la tarea ha terminado

        execute_actions(page, call.actions)  # tu gestor de acciones (Lección 4)
        screenshot = capture_screen(page)

        response = client.responses.create(
            model="gpt-6.1-sol",
            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",
                },
            }],
        )

Este bucle aún no tiene barreras de seguridad: en producción, limita el número de turnos, la duración y el coste; detén la ejecución si una llamada incluye comprobaciones de seguridad pendientes (pending_safety_checks); y verifica el resultado real en lugar de confiar solo en el mensaje final del modelo. Estas son las directrices de seguridad de OpenAI, tratadas en la Lección 12.

Cuánto cuesta un turno del bucle

Cada solicitud a la API de Responses cobra por los tokens de entrada y salida, y cada captura de pantalla cuenta como una entrada de imagen; un entorno alojado puede facturarse por separado. Por tanto, el coste de una tarea depende del número de turnos, del tamaño de la captura de pantalla y del modelo, y crece más rápido que el número de turnos, porque incluso con previous_response_id, todos los tokens de entrada de las respuestas anteriores de la cadena se vuelven a cobrar como entrada en cada solicitud. OpenAI proporciona una calculadora de costes de imágenes y expone el uso de cada solicitud: mide en tus propios flujos de trabajo antes de presupuestar. Un script de Selenium hará siempre lo mismo más rápido y más barato, pero tendrás que reescribirlo la próxima vez que cambie el formulario, algo que el agente no requiere.

Puntos clave

  • El bucle tarea → acciones → captura de pantalla es el corazón de Computer Use; tu aplicación ejecuta las acciones
  • Con OpenAI, declara la herramienta con tools=[{"type": "computer"}] en la API de Responses
  • Un computer_call contiene una lista ordenada de acciones (click, type, scroll, keypress, etc.) para ejecutar en secuencia
  • La captura de pantalla vuelve al modelo en un computer_call_output con el mismo call_id, encadenado mediante previous_response_id
  • Cada turno cuesta tokens y una imagen: limita los turnos y mide antes de presupuestar