Cómo hacer que Claude controle tu PC (Computer Use)

Computer Use es la capacidad de Claude para interactuar con un ordenador como lo haría una persona: mira capturas de pantalla, mueve el ratón, escribe con el teclado y ejecuta comandos. No controla directamente tu máquina física: tú ejecutas un bucle que recibe las acciones que Claude quiere realizar (herramienta 'computer') y las aplicas en un entorno. Por eso lo correcto y seguro es usar un contenedor Docker aislado, nunca tu PC de trabajo con acceso a datos sensibles. Primero, consigue tu API key en console.anthropic.com y expórtala como variable de entorno. En España y LATAM funciona igual; solo asegúrate de tener saldo o plan activo, ya que Computer Use consume tokens rápido por las capturas de pantalla que envía en cada iteración.

export ANTHROPIC_API_KEY="sk-ant-tu-clave-aqui"
# Verifica que está cargada
echo $ANTHROPIC_API_KEY

Anthropic publica una imagen Docker de referencia que incluye un entorno de escritorio Linux completo con navegador, herramientas y un servidor que recibe las acciones de Claude. Es la forma más rápida y segura de empezar sin exponer tu máquina. El contenedor abre un puerto (8080) con una interfaz web donde ves en vivo lo que Claude hace en el escritorio virtual, y otro puerto (5900) para VNC si prefieres cliente nativo. Al arrancarlo le pasas tu API key. Todo lo que Claude toque queda dentro del contenedor: si algo sale mal, lo destruyes y listo. Este es el enfoque recomendado por Anthropic para producción y pruebas.

docker run \
  -e ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY \
  -v $HOME/.anthropic:/home/computeruse/.anthropic \
  -p 5900:5900 \
  -p 8080:8080 \
  -p 8501:8501 \
  -p 6080:6080 \
  -it ghcr.io/anthropics/anthropic-quickstarts:computer-use-demo-latest

Si quieres controlar el flujo tú mismo (no usar la demo), debes declarar la herramienta 'computer' con su versión y las dimensions de la pantalla. Claude Opus 4 usa el tipo de herramienta computer_20250124. Debes indicar el ancho, alto y el número de display. Junto a 'computer' suele añadirse 'bash' y 'text_editor' para comandos y edición de archivos. Es clave activar el beta header correspondiente. La resolución recomendada es 1280x800 o menor: resoluciones altas degradan la precisión del modelo al localizar coordenadas y encarecen las capturas.

import anthropic

client = anthropic.Anthropic()

tools = [
    {
        "type": "computer_20250124",
        "name": "computer",
        "display_width_px": 1280,
        "display_height_px": 800,
        "display_number": 1,
    },
    {"type": "bash_20250124", "name": "bash"},
    {"type": "text_editor_20250124", "name": "str_replace_based_edit_tool"},
]

response = client.beta.messages.create(
    model="claude-opus-4-8",
    max_tokens=2048,
    tools=tools,
    messages=[{"role": "user", "content": "Abre el navegador y busca el tiempo en Madrid"}],
    betas=["computer-use-2025-01-24"],
)
print(response.content)

Claude no ejecuta acciones solo: responde con bloques 'tool_use' describiendo qué quiere hacer (por ejemplo, screenshot, click en x,y, escribir texto). Tu código debe ejecutar esa acción en el entorno, capturar el resultado (normalmente una nueva captura de pantalla) y devolverlo como 'tool_result'. Repites hasta que Claude deja de pedir herramientas (stop_reason distinto de 'tool_use'). Este bucle es el corazón de Computer Use. Aquí muestro el esqueleto; la función execute_action debe conectar con tu entorno (xdotool, pyautogui dentro del contenedor, etc.). La demo de Anthropic ya trae esta lógica implementada.

def run_agent_loop(client, tools, messages):
    while True:
        resp = client.beta.messages.create(
            model="claude-opus-4-8",
            max_tokens=2048,
            tools=tools,
            messages=messages,
            betas=["computer-use-2025-01-24"],
        )
        messages.append({"role": "assistant", "content": resp.content})

        if resp.stop_reason != "tool_use":
            return resp

        tool_results = []
        for block in resp.content:
            if block.type == "tool_use":
                # execute_action aplica la accion en el entorno aislado
                result = execute_action(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,  # texto o imagen base64
                })
        messages.append({"role": "user", "content": tool_results})

Dentro del contenedor Linux, las acciones se traducen a comandos del sistema. Para mover el ratón y hacer clic se usa xdotool; para capturas, scrot o import. La demo de Anthropic ya mapea cada 'action' (screenshot, left_click, type, key, mouse_move) a estos comandos. Si construyes tu propio ejecutor, este es el patrón mínimo para las acciones más comunes. La captura de pantalla se devuelve en base64 para que Claude 'vea' el resultado de cada acción y decida el siguiente paso.

import subprocess, base64

def execute_action(name, inp):
    action = inp.get("action")
    if action == "screenshot":
        subprocess.run(["scrot", "/tmp/shot.png"])
        with open("/tmp/shot.png", "rb") as f:
            data = base64.b64encode(f.read()).decode()
        return [{"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": data}}]
    if action == "left_click":
        x, y = inp["coordinate"]
        subprocess.run(["xdotool", "mousemove", str(x), str(y), "click", "1"])
        return "clicked"
    if action == "type":
        subprocess.run(["xdotool", "type", inp["text"]])
        return "typed"
    if action == "key":
        subprocess.run(["xdotool", "key", inp["text"]])
        return "key sent"
    return "accion no soportada"

Darle control de un ordenador a un modelo tiene riesgos reales: puede seguir instrucciones maliciosas incrustadas en una web (prompt injection), realizar acciones irreversibles o entrar en bucles caros. Blíndate. Primero: aislamiento total, sin acceso a credenciales reales ni a tu red interna. Segundo: pon un límite de iteraciones en el bucle para evitar gastos descontrolados. Tercero: exige confirmación humana antes de acciones sensibles (compras, envíos, borrados). Cuarto: usa allowlists de dominios si navega. Nunca conectes Computer Use a sistemas de producción sin supervisión. Anthropic clasifica esta función como experimental precisamente por estos riesgos.

MAX_ITER = 15
ACCIONES_PELIGROSAS = {"submit", "purchase", "delete"}

def guard(block):
    accion = block.input.get("action", "")
    if accion in ACCIONES_PELIGROSAS:
        ok = input(f"Claude quiere '{accion}'. Autorizar? (s/n) ")
        if ok.lower() != "s":
            return "accion cancelada por el usuario"
    return None