Lo que vas a aprender
- Qué es Computer Use y por qué necesita un entorno aislado
- Levantar el contenedor de referencia de Anthropic con Docker
- Enviar instrucciones a Claude para que controle pantalla, teclado y ratón
- Implementar el bucle agéntico (tool_use → ejecución → tool_result)
- Medidas de seguridad imprescindibles antes de darle control a un modelo
Paso 1: Entender Computer Use y preparar la API key
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_KEYConsejo: Guarda la key en un archivo .env y añádelo a .gitignore para no filtrarla en repositorios.
Error común: Nunca ejecutes Computer Use directamente sobre tu PC personal con acceso a tu correo, banca o archivos. Usa siempre un entorno aislado.
Paso 2: Levantar el contenedor de referencia de Anthropic
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-latestConsejo: Abre http://localhost:8080 en tu navegador para ver el escritorio virtual y una interfaz de chat lado a lado.
Error común: Si Docker da error de permisos en Linux, añade tu usuario al grupo docker o usa sudo. En Windows/Mac necesitas Docker Desktop corriendo.
Paso 3: Definir la herramienta computer en una llamada API propia
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)Consejo: Mantén display_width/height por debajo de 1366x768; Anthropic reduce la precisión con resoluciones mayores.
Error común: Sin el header beta 'computer-use-2025-01-24' la API rechaza la herramienta computer con un error de tipo no soportado.
Paso 4: Implementar el bucle agéntico
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})Consejo: Loggea cada tool_use antes de ejecutarlo: es tu única forma de auditar qué intentó hacer el modelo.
Error común: No olvides añadir la respuesta del assistant a messages antes de mandar el tool_result, o la API dará error de secuencia de mensajes inválida.
Paso 5: Ejecutar acciones reales dentro del contenedor
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"Consejo: Devuelve siempre una captura tras cada acción de ratón/teclado: Claude necesita verificar visualmente que funcionó.
Error común: xdotool requiere que la variable DISPLAY apunte al servidor X del contenedor (normalmente :1). Si falla, exporta DISPLAY=:1.
Paso 6: Aplicar controles de seguridad y límites
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 NoneConsejo: Ejecuta el contenedor con --network none si la tarea no necesita internet: elimina de raíz la prompt injection vía web.
Error común: Nunca metas cookies de sesión, tokens OAuth o gestores de contraseñas reales en el entorno. Un prompt injection podría exfiltrarlos.
Resultado
Has montado un entorno completo y aislado donde Claude Opus 4 puede controlar un ordenador: ver la pantalla, mover el ratón, escribir y ejecutar comandos mediante la herramienta Computer Use. Entiendes el bucle agéntico tool_use → ejecución → tool_result que hace posible la automatización, sabes traducir las acciones a comandos reales dentro de un contenedor Docker, y has aplicado las medidas de seguridad imprescindibles (aislamiento, límite de iteraciones y confirmación humana) para usar esta función experimental sin poner en riesgo tus datos.
