computer-use-agents

# Dockerfile for sandboxed computer use environment
# Based on Anthropic's reference implementation pattern
 
FROM ubuntu:22.04
 
# Install desktop environment
RUN apt-get update && apt-get install -y \
    xvfb \
    x11vnc \
    fluxbox \
    xterm \
    firefox \
    python3 \
    python3-pip \
    supervisor
 
# Security: Create non-root user
RUN useradd -m -s /bin/bash agent && \
    mkdir -p /home/agent/.vnc
 
# Install Python dependencies
COPY requirements.txt /tmp/
RUN pip3 install -r /tmp/requirements.txt
 
# Security: Drop capabilities
RUN apt-get install -y --no-install-recommends libcap2-bin && \
    setcap -r /usr/bin/python3 || true
 
# Copy agent code
COPY --chown=agent:agent . /app
WORKDIR /app
 
# Supervisor config for virtual display + VNC
COPY supervisord.conf /etc/supervisor/conf.d/
 
# Expose VNC port only (not desktop directly)
EXPOSE 5900
 
# Run as non-root
USER agent
 
CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.conf"]
 
---
 
# docker-compose.yml with security constraints
version: '3.8'
 
services:
  computer-use-agent:
    build: .
    ports:
      - "5900:5900"  # VNC for observation
      - "8080:8080"  # API for control
 
    # Security constraints
    security_opt:
      - no-new-privileges:true
      - seccomp:seccomp-profile.json
 
    # Resource limits
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 4G
        reservations:
          cpus: '0.5'
          memory: 1G
 
    # Network isolation
    networks:
      - agent-network
 
    # No access to host filesystem
    volumes:
      - agent-tmp:/tmp
 
    # Read-only root filesystem
    read_only: true
    tmpfs:
      - /run
      - /var/run
 
    # Environment
    environment:
      - DISPLAY=:99
      - NO_PROXY=localhost
 
networks:
  agent-network:
    driver: bridge
    internal: true  # No internet by default
 
volumes:
  agent-tmp:
 
---
 
# Python wrapper with additional runtime sandboxing
import subprocess
import os
from dataclasses im

from anthropic import Anthropic
from anthropic.types.beta import (
    BetaToolComputerUse20241022,
    BetaToolBash20241022,
    BetaToolTextEditor20241022,
)
import subprocess
import base64
from PIL import Image
import io
 
class AnthropicComputerUse:
    """
    Official Anthropic Computer Use implementation.
 
    Requires:
    - Docker container with virtual display
    - VNC for viewing agent actions
    - Proper tool implementations
    """
 
    def __init__(self):
        self.client = Anthropic()
        self.model = "claude-sonnet-4-20250514"  # Best for computer use
        self.screen_size = (1280, 800)
 
    def get_tools(self) -> list:
        """Define computer use tools."""
        return [
            BetaToolComputerUse20241022(
                type="computer_20241022",
                name="computer",
                display_width_px=self.screen_size[0],
                display_height_px=self.screen_size[1],
            ),
            BetaToolBash20241022(
                type="bash_20241022",
                name="bash",
            ),
            BetaToolTextEditor20241022(
                type="text_editor_20241022",
                name="str_replace_editor",
            ),
        ]
 
    def execute_tool(self, name: str, input: dict) -> dict:
        """Execute a tool and return result."""
 
        if name == "computer":
            return self._handle_computer_action(input)
        elif name == "bash":
            return self._handle_bash(input)
        elif name == "str_replace_editor":
            return self._handle_editor(input)
        else:
            return {"error": f"Unknown tool: {name}"}
 
    def _handle_computer_action(self, input: dict) -> dict:
        """Handle computer control actions."""
        action = input.get("action")
 
        if action == "screenshot":
            # Capture via xdotool/scrot
            subprocess.run(["scrot", "/tmp/screenshot.png"])
 
            with open("/tmp/screenshot.png", "rb") as f: