Computer use con Claude: tutorial de automatización UI sin API

Computer use es la última opción, no la primera. Antes de usar computer use, descartar:

• ¿El sistema tiene API REST o GraphQL? Usar API directa.
• ¿El sistema tiene MCP server oficial o comunitario? Usar MCP.
• ¿Hay scraper estructurado disponible? Usar scraper.
• ¿La acción es repetible mediante RPA tradicional (UiPath, Power Automate)? Evaluar costo vs computer use.

Si TODAS las opciones anteriores no aplican, computer use es candidato. Casos típicos donde sí conviene:

• Portales legacy de proveedores sin API.
• Sistemas internos heredados que requieren autenticación interactiva.
• Operaciones puntuales de baja frecuencia donde RPA es excesivo.
• Procesos donde la UI cambia ocasionalmente (computer use se adapta).

pip install anthropic pillow pyautogui

Para corridas seguras recomendamos VM o container (no en tu máquina principal):

docker run -it --rm --network host \
  -v $(pwd):/work \
  -e ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY \
  ubuntu:24.04 bash

En Python:

from anthropic import Anthropic
import pyautogui
import io
import base64

client = Anthropic()

def take_screenshot() -> str:
    """Captura pantalla y retorna en base64."""
    img = pyautogui.screenshot()
    buffer = io.BytesIO()
    img.save(buffer, format='PNG')
    return base64.b64encode(buffer.getvalue()).decode('utf-8')

def execute_action(action: dict):
    """Ejecuta la acción decidida por Claude."""
    if action['action'] == 'click':
        x, y = action['coordinate']
        pyautogui.click(x, y)
    elif action['action'] == 'type':
        pyautogui.write(action['text'], interval=0.05)
    elif action['action'] == 'key':
        pyautogui.press(action['key'])
    # ... más acciones según necesidad

def agent_loop(goal: str, max_iterations: int = 20):
    messages = [{"role": "user", "content": goal}]

    for iteration in range(max_iterations):
        screenshot_b64 = take_screenshot()

        response = client.messages.create(
            model="claude-opus-4-7",
            max_tokens=4096,
            tools=[{
                "type": "computer_20250101",
                "name": "computer",
                "display_width_px": 1920,
                "display_height_px": 1080,
            }],
            messages=messages + [
                {
                    "role": "user",
                    "content": [{
                        "type": "image",
                        "source": {
                            "type": "base64",
                            "media_type": "image/png",
                            "data": screenshot_b64,
                        },
                    }],
                }
            ],
        )

        # Si Claude indica que terminó, salir
        if response.stop_reason == 'end_turn':
            print("Objetivo cumplido")
            break

        # Ejecutar las tool calls
        for block in response.content:
            if block.type == 'tool_use':
                execute_action(block.input)

agent_loop("Abre el portal SII y descarga el último Form 29")

Este código es esquemático. Para producción requiere manejo robusto de errores, reintentos, validación de estados y guardrails.

Costos

Computer use consume tokens de input significativos (cada screenshot ocupa miles de tokens). Para una tarea típica de 15-20 pasos con Opus 4.7: USD 0.50-2.00 por ejecución completa. Para 100 ejecuciones/día: USD 50-200/día (CLP 1.5-6M/mes).

Reducir costo usando Sonnet 4.6 (10x más barato) cuando la calidad lo permite, screenshots a resolución menor, paginación de pasos.

Límites importantes

• No es determinista: la misma tarea puede tomar más o menos pasos según el estado del sistema.
• Vulnerable a cambios visuales del sistema destino (re-diseño, A/B testing del proveedor).
• Latencia alta: cada paso requiere screenshot + LLM call + ejecución (~5-10 segundos por paso).
• Riesgo de error en operaciones críticas: NUNCA usar para operaciones destructivas sin human-in-the-loop.
• Captcha y autenticación 2FA pueden bloquear ejecución.
• Algunos sistemas tienen términos que prohíben automatización no autorizada.

• Playwright + scripting: para automatizaciones de navegador estables y de alta frecuencia.
• RPA tradicional (UiPath, Power Automate): mejor TCO para procesos repetitivos volumen alto.
• Construir adapter custom: si el sistema tiene autoridad legal/comercial para integración, exigir API.
• Combinación: Playwright para navegación + Claude vision para extracción de campos no estructurados.