Primer flujo de trabajo: navegar e interactuar
En esta página
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
computerde la API de Responses, un gestor de acciones modelado según la documentación (acciones agrupadas,keypress,scroll_x/scroll_y, trayectorias dedrag) y el encadenamiento medianteprevious_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_outputcon el mismocall_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_checksy usaheadless=Falsedurante el desarrollo run_agent(task, page=page)reutiliza este bucle para una página ya abierta; esto es lo que usan las siguientes lecciones