title: "Computer Use в 2026: Anthropic Claude Opus 4.6, OpenAI Operator/CUA и стек GUI-автоматизации" slug: computer-use-anthropic-xdotool-2026-ru date: 2026-02-26 lang: ru

Computer Use в 2026: Anthropic Claude Opus 4.6, OpenAI Operator/CUA и стек GUI-автоматизации

Ключевые факты

• Текущие модели Anthropic с computer use: Claude Opus 4.6, Claude Sonnet 4.6, Claude Opus 4.5, Claude Sonnet 4.5, Claude Haiku 4.5, все Claude 4 модели и Claude Sonnet 3.7
• Версии инструментов: computer_20251124 (Opus 4.6, Sonnet 4.6, Opus 4.5) и computer_20250124 (все остальные поддерживаемые модели)
• Бета-флаги: computer-use-2025-11-24 для последней версии инструмента, computer-use-2025-01-24 для более старых моделей
• Типы действий скриншота: screenshot, left_click, right_click, middle_click, double_click, triple_click, type, key, scroll, mouse_move, left_click_drag, left_mouse_down, left_mouse_up, hold_key, wait
• Действие масштабирования: Доступно только в computer_20251124 (Opus 4.6, Opus 4.5); требует enable_zoom: true в определении инструмента
• Ограничения разрешения скриншота: Максимум 1568 пикселей по длинному краю, примерно 1,15 мегапикселя в сумме (1512×982 → ~1330×864)
• Требование масштабирования координат: Требуется, когда фактическое разрешение экрана отличается от предполагаемых Claude размеров дисплея
• Overhead системного промпта: 466-499 токенов, добавляемых автоматически для бета-версии computer use
• Стоимость определения инструмента: 735 токенов за определение инструмента computer use (Claude 4.x и Sonnet 3.7)
• Модель ценообразования: Стандартное ценообразование tool use + стоимость токенов видения для скриншотов
• Совместимость версий xdotool: Работает со стандартным xdotool на X11; Wayland требует альтернативных библиотек автоматизации
• Поддерживаемые серверы дисплея: X11 (полная поддержка через xdotool), Wayland (требует native инструментов Wayland, не xdotool), macOS/Windows (через pyautogui)
• Требование изоляции безопасности: Docker-контейнеры или виртуальные машины настоятельно рекомендуются; нет покрытия ZDR для бета-версии
• Риск prompt injection: Claude может следовать инструкциям, найденным в скриншотах или веб-контенте, потенциально конфликтуя с инструкциями пользователя
• Шлюзы подтверждения человеком: Требуются для финансовых транзакций, входов в учетные записи, необратимых операций с данными и согласия с условиями обслуживания
• Паттерн Docker-изоляции: Непривилегированный пользователь, --network none, --read-only файловая система, ограничения памяти/CPU, tmpfs для временных файлов
• Песочница E2B Desktop: На базе Firecracker microVMs, <200ms время запуска, изоляция на уровне ядра для мультитенантных развертываний
• Задержки выполнения действий: 100-500ms рекомендуется между действиями для разрешения обновлений UI и загрузки страниц
• Максимум итераций: Реализуйте жесткие ограничения (обычно 10-50) для предотвращения неконтролируемых затрат API в циклах агента
• Производительность бенчмарков: 72,7% на бенчмарке OSWorld (Claude Opus 4.6), state-of-the-art среди одноагентных систем на WebArena

Что такое Computer Use

Computer use — это основанная на видении возможность GUI-автоматизации Anthropic, которая позволяет Claude взаимодействовать с окружением рабочего стола через цикл screenshot-action. Вместо вызова структурированных API, Claude воспринимает экран компьютера как человек — анализируя пиксели, определяя интерактивные элементы и выполняя действия мыши и клавиатуры на основе визуального понимания.

Основной цикл работает следующим образом:

1. Захват скриншота: Текущее состояние дисплея захватывается как изображение PNG или JPEG
2. Анализ видения: Скриншот отправляется Claude вместе с инструкциями задачи пользователя
3. Решение о действии: Claude анализирует визуальное состояние, рассуждает о следующих шагах и запрашивает конкретное действие (клик по координатам, ввод текста, нажатие клавиши, прокрутка)
4. Выполнение действия: Ваше приложение выполняет запрошенное действие в вычислительной среде (через xdotool, pyautogui, Playwright или E2B)
5. Обновление состояния: Новый скриншот захватывается, показывающий результат действия
6. Продолжение цикла: Шаги 2-5 повторяются до тех пор, пока Claude не определит, что задача выполнена, или не достигнет лимитов итераций

Claude не выполняет действия напрямую. Инструмент computer use — это инструмент без схемы, где Claude запрашивает действия как структурированный JSON, а ваше приложение отвечает за преобразование этих запросов в фактические системные вызовы. Эта архитектура обеспечивает контроль над песочницей, политиками безопасности и окружениями выполнения.

Фреймворк решений

Computer Use vs Playwright vs RPA vs Browser-use

Дерево решений:

• Нужно автоматизировать десктопные приложения или терминал? → Anthropic Computer Use
• Браузерная задача со стабильной структурой DOM? → Playwright
• Браузерная задача с часто меняющимся DOM? → Browser-use или OpenAI CUA
• Многоприложенческий рабочий поток (браузер + рабочий стол + терминал)? → Anthropic Computer Use
• Потребительский продукт, требующий нулевой локальной настройки? → OpenAI Operator (когда API доступен)
• Нужно максимально быстрое выполнение? → Playwright
• Нужна минимальная стоимость? → Playwright
• Нужна максимальная гибкость и адаптация к изменениям UI? → Anthropic Computer Use или OpenAI CUA

Таблица справочников параметров

Определение инструмента Computer Use

Параметры запроса API

Параметры входа действия

Типичные ошибки

1. Несоответствие масштабирования координат

Проблема: Клики Claude по координатам промахиваются мимо целей, потому что скриншоты уменьшаются API, но координаты не масштабируются обратно для выполнения.

❌ Неправильно:

screenshot = capture_screenshot(width=1920, height=1080)
send_to_claude(screenshot)  # API уменьшает до ~1330x864
# Claude возвращает координаты в уменьшенном пространстве
execute_click(x=640, y=400)  # Клик в неправильном месте в пространстве 1920x1080

✅ Правильно:

scale = get_scale_factor(1920, 1080)  # Возвращает ~0.69
scaled_width = int(1920 * scale)  # 1330
scaled_height = int(1080 * scale)  # 750
screenshot = capture_and_resize(scaled_width, scaled_height)
send_to_claude(screenshot)
# Claude возвращает координаты в масштабированном пространстве
screen_x = x / scale  # Масштабируем обратно в пространство экрана
screen_y = y / scale
execute_click(screen_x, screen_y)

Воздействие: Высокая частота отказов при клик-действиях, Claude повторно кликает по неправильным элементам.

2. Отсутствие задержек действий

Проблема: Выполнение действий слишком быстро без ожидания обновлений UI приводит к тому, что Claude анализирует устаревшие скриншоты и принимает неправильные решения.

❌ Неправильно:

execute_action(action)
screenshot = take_screenshot()  # Захвачен до обновления UI
send_to_claude(screenshot)

✅ Правильно:

execute_action(action)
time.sleep(0.5)  # Разрешаем UI стабилизироваться
try:
    page.wait_for_load_state("networkidle", timeout=3000)
except TimeoutError:
    pass  # Не все действия вызывают навигацию
screenshot = take_screenshot()
send_to_claude(screenshot)

Воздействие: Claude видит старое состояние UI, принимает решения на основе устаревшей информации, застревает в циклах, пытаясь выполнить уже выполненные действия.

3. Отсутствие лимита итераций в цикле агента

Проблема: Цикл агента работает бесконечно, если Claude застревает или не распознает завершение задачи, вызывая неконтролируемые затраты API.

❌ Неправильно:

while True:
    response = client.beta.messages.create(...)
    if response.stop_reason == "end_turn":
        break
    execute_tools(response)

✅ Правильно:

MAX_ITERATIONS = 30
for iteration in range(MAX_ITERATIONS):
    response = client.beta.messages.create(...)
    if response.stop_reason == "end_turn":
        break
    execute_tools(response)
else:
    log_error(f"Max iterations ({MAX_ITERATIONS}) reached without completion")

Воздействие: Потенциальные сотни долларов затрат API, если цикл работает без контроля; задача никогда не завершается.

4. Запуск без песочницы

Проблема: Выполнение computer use на host-системе без изоляции раскрывает production-учетные данные, позволяет prompt injection экспортировать данные и разрешает необратимые деструктивные действия.

❌ Неправильно:

# Запуск непосредственно на хост-машине с доступом к ~/.ssh, ~/.aws, production БД
execute_computer_action(action)

✅ Правильно:

docker run -d \
  --network none \
  --read-only \
  --memory 2g \
  --cpus 2 \
  --tmpfs /tmp \
  --tmpfs /home/agent \
  -e AGENT_TASK="$task" \
  computer-use-sandbox:latest

Воздействие: Критический риск безопасности — кража учетных данных, экспортирование данных, случайное удаление production-данных.

5. Отсутствие обработки ошибок инструментов

Проблема: Когда захват скриншота не удается или действия ошибаются, возврат пустых/null результатов разрушает цикл рассуждений Claude.

❌ Неправильно:

try:
    screenshot = capture_screenshot()
except Exception:
    screenshot = None  # Claude получает null, не может рассуждать об ошибке

✅ Правильно:

try:
    screenshot = capture_screenshot()
    return {"type": "image", "source": {"type": "base64", "data": screenshot}}
except Exception as e:
    return {
        "type": "tool_result",
        "tool_use_id": tool_id,
        "content": f"Error: Failed to capture screenshot. {str(e)}",
        "is_error": True
    }

Воздействие: Claude не может диагностировать или восстановиться после отказов; цикл завершается преждевременно или производит бессмысленные ответы.

Реализация Anthropic Computer Use

Структура вызова API

Полный вызов API computer use включает модель, массив инструментов, сообщения, флаг бета и опциональную конфигурацию thinking:

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-4-6",
    max_tokens=4096,
    tools=[
        {
            "type": "computer_20251124",
            "name": "computer",
            "display_width_px": 1280,
            "display_height_px": 800,
            "display_number": 1,
        },
        {
            "type": "text_editor_20250728",
            "name": "str_replace_based_edit_tool",
        },
        {
            "type": "bash_20250124",
            "name": "bash",
        }
    ],
    messages=[
        {"role": "user", "content": "Open Firefox and navigate to https://example.com"}
    ],
    betas=["computer-use-2025-11-24"],
)

Захват скриншота

Захватите текущее состояние дисплея, используя scrot (X11), PIL/pyautogui (кроссплатформенно) или встроенный API скриншота E2B:

import base64
import subprocess

def take_screenshot() -> str:
    """Capture current screen state as base64-encoded PNG."""
    result = subprocess.run(
        ["scrot", "-", "-q", "80"],
        capture_output=True,
        check=True
    )
    return base64.standard_b64encode(result.stdout).decode("utf-8")

С масштабированием координат:

import math
from PIL import ImageGrab

def get_scale_factor(width: int, height: int) -> float:
    """Calculate scale factor to meet API constraints."""
    long_edge = max(width, height)
    total_pixels = width * height

    long_edge_scale = 1568 / long_edge
    total_pixels_scale = math.sqrt(1_150_000 / total_pixels)

    return min(1.0, long_edge_scale, total_pixels_scale)

def take_scaled_screenshot(width: int, height: int) -> tuple[str, float]:
    """Capture and resize screenshot, return base64 PNG and scale factor."""
    screenshot = ImageGrab.grab()
    scale = get_scale_factor(width, height)

    scaled_width = int(width * scale)
    scaled_height = int(height * scale)

    resized = screenshot.resize((scaled_width, scaled_height))

    buffer = io.BytesIO()
    resized.save(buffer, format="PNG")
    b64_data = base64.b64encode(buffer.getvalue()).decode("utf-8")

    return b64_data, scale

Выполнение действий

Преобразуйте запросы действий Claude в системные вызовы. Слой выполнения должен обрабатывать все типы действий, возвращаемые Claude:

import subprocess
import time
from typing import Optional

def execute_computer_action(action: dict, scale: float = 1.0) -> Optional[str]:
    """
    Execute a computer action returned by Claude.
    Returns screenshot b64 if action was 'screenshot', otherwise None.
    """
    action_type = action["action"]

    if action_type == "screenshot":
        screenshot_b64, _ = take_scaled_screenshot(SCREEN_WIDTH, SCREEN_HEIGHT)
        return screenshot_b64

    elif action_type == "left_click":
        x, y = action["coordinate"]
        # Scale coordinates back to screen space
        screen_x = int(x / scale)
        screen_y = int(y / scale)
        subprocess.run(["xdotool", "mousemove", "--sync", str(screen_x), str(screen_y)], check=True)
        subprocess.run(["xdotool", "click", "1"], check=True)

    elif action_type == "type":
        subprocess.run(
            ["xdotool", "type", "--clearmodifiers", "--delay", "30", action["text"]],
            check=True
        )

    elif action_type == "key":
        subprocess.run(
            ["xdotool", "key", "--clearmodifiers", action["key"]],
            check=True
        )

    elif action_type == "scroll":
        x, y = action["coordinate"]
        screen_x = int(x / scale)
        screen_y = int(y / scale)
        direction = action.get("scroll_direction", "down")
        amount = action.get("scroll_amount", 3)

        subprocess.run(["xdotool", "mousemove", "--sync", str(screen_x), str(screen_y)], check=True)
        button = "4" if direction == "up" else "5"
        for _ in range(amount):
            subprocess.run(["xdotool", "click", button], check=True)

    return None

Цикл агента

Цикл агента обрабатывает разговор с Claude, выполняет запросы инструментов и возвращает результаты до завершения задачи:

def run_computer_use_agent(task: str, max_iterations: int = 30) -> str:
    """
    Main agent loop. Runs until Claude signals completion or max_iterations reached.
    Returns summary of what was accomplished.
    """
    tools = [
        {
            "type": "computer_20251124",
            "name": "computer",
            "display_width_px": SCREEN_WIDTH,
            "display_height_px": SCREEN_HEIGHT,
            "display_number": 1,
        },
    ]

    messages = [{"role": "user", "content": task}]
    screenshot_b64, scale = take_scaled_screenshot(SCREEN_WIDTH, SCREEN_HEIGHT)

    for iteration in range(max_iterations):
        response = client.beta.messages.create(
            model="claude-opus-4-6",
            max_tokens=4096,
            tools=tools,
            messages=messages,
            betas=["computer-use-2025-11-24"],
        )

        assistant_content = response.content
        messages.append({"role": "assistant", "content": assistant_content})

        if response.stop_reason == "end_turn":
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
            return "Task completed."

        tool_results = []
        for block in response.content:
            if block.type != "tool_use":
                continue

            tool_input = block.input
            result_screenshot = execute_computer_action(tool_input, scale)
            time.sleep(0.5)  # Allow UI to settle

            if result_screenshot:
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": [
                        {
                            "type": "image",
                            "source": {
                                "type": "base64",
                                "media_type": "image/png",
                                "data": result_screenshot,
                            },
                        }
                    ],
                })
            else:
                screenshot_b64, scale = take_scaled_screenshot(SCREEN_WIDTH, SCREEN_HEIGHT)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": [
                        {
                            "type": "image",
                            "source": {
                                "type": "base64",
                                "media_type": "image/png",
                                "data": screenshot_b64,
                            },
                        }
                    ],
                })

        if tool_results:
            messages.append({"role": "user", "content": tool_results})

    return f"Reached max iterations ({max_iterations}) without completing task."

Интеграция xdotool

Основы X11 автоматизации

xdotool — это утилита X11 автоматизации, которая синтезирует события клавиатуры и мыши на уровне X-сервера. Это стандартный бэкенд выполнения для reference-реализации Anthropic и работает надежно на Linux-системах, работающих на X11 (не Wayland).

Ключевые команды xdotool:

# Переместить мышь на координаты (--sync ожидает завершения X события)
xdotool mousemove --sync 640 400

# Клик кнопками: 1=левый, 2=средний, 3=правый, 4=прокрутка-вверх, 5=прокрутка-вниз
xdotool click 1

# Ввести текст с задержкой между символами (предотвращает потерю нажатий)
xdotool type --clearmodifiers --delay 30 "hello world"

# Нажать комбинацию клавиш (X11 keysym имена)
xdotool key ctrl+c
xdotool key Return
xdotool key Escape

# Найти окно по имени и активировать его
xdotool search --name "Firefox" windowactivate --sync

# Получить текущую позицию мыши
xdotool getmouselocation

Имитация клавиш

Используйте xdotool key для клавиатурных ярлыков и xdotool type для ввода текста. Всегда используйте --clearmodifiers для освобождения клавиш модификаторов, которые могут быть застрявшими:

def press_key(key: str):
    """Press a key or key combination."""
    subprocess.run(["xdotool", "key", "--clearmodifiers", key], check=True)

def type_text(text: str):
    """Type text with delay between characters."""
    subprocess.run(
        ["xdotool", "type", "--clearmodifiers", "--delay", "30", text],
        check=True
    )

Часто используемые сопоставления клавиш:

Управление окнами

xdotool может находить, фокусировать и манипулировать окнами:

# Найти окно по шаблону имени
xdotool search --name "Firefox"

# Активировать (сфокусировать) окно
xdotool windowactivate --sync <window_id>

# Получить ID активного окна
xdotool getactivewindow

# Переместить окно на определенную позицию
xdotool windowmove <window_id> 0 0

# Изменить размер окна
xdotool windowsize <window_id> 1280 800

# Минимизировать окно
xdotool windowminimize <window_id>

Пример использования в Python:

def focus_firefox():
    """Find Firefox window and bring it to front."""
    result = subprocess.run(
        ["xdotool", "search", "--name", "Firefox"],
        capture_output=True,
        text=True
    )
    if result.stdout.strip():
        window_id = result.stdout.strip().split()[0]
        subprocess.run(
            ["xdotool", "windowactivate", "--sync", window_id],
            check=True
        )

Совместимость Wayland

Важно: xdotool не работает на Wayland. Для систем Wayland используйте:

• ydotool: Альтернатива Wayland xdotool (требует прав root или uinput)
• wtype: Инструмент ввода текста Wayland
• pyautogui: Кроссплатформенная библиотека, которая работает на Wayland (использует evdev на Linux)

# Пример ydotool (Wayland)
ydotool mousemove --absolute 640 400
ydotool click 1
ydotool type "hello world"

Production-настройка

Конфигурация VNC/Display-сервера

Для server-side computer use без физического монитора установите virtual framebuffer (Xvfb) и опциональный VNC-сервер для удаленного просмотра:

# Установить зависимости
apt-get update && apt-get install -y \
    xvfb x11-utils xdotool scrot fluxbox \
    firefox-esr python3 python3-pip \
    tightvncserver x11vnc

# Запустить virtual display размером 1280x800 с 24-битным цветом
Xvfb :99 -screen 0 1280x800x24 -ac +extension GLX &
export DISPLAY=:99

# Запустить легкий window manager (требуется для некоторых приложений)
DISPLAY=:99 fluxbox &

# Опционально: Запустить VNC-сервер для удаленного просмотра
x11vnc -display :99 -nopw -listen 0.0.0.0 -forever &

# Запустить браузер в virtual display
DISPLAY=:99 firefox --no-sandbox &

Программатическое управление virtual display:

import subprocess
import os
import atexit

class VirtualDisplay:
    def __init__(self, display_num: int = 99, width: int = 1280, height: int = 800):
        self.display_num = display_num
        self.width = width
        self.height = height
        self.xvfb_process = None

    def start(self):
        self.xvfb_process = subprocess.Popen([
            "Xvfb", f":{self.display_num}",
            "-screen", "0", f"{self.width}x{self.height}x24",
            "-ac",
            "+extension", "GLX",
        ])
        os.environ["DISPLAY"] = f":{self.display_num}"
        time.sleep(1)  # Give Xvfb time to initialize
        atexit.register(self.stop)
        return self

    def stop(self):
        if self.xvfb_process:
            self.xvfb_process.terminate()
            self.xvfb_process.wait()

    def __enter__(self):
        return self.start()

    def __exit__(self, *args):
        self.stop()

Настройка Docker-контейнера

Создайте безопасный, изолированный контейнер для выполнения computer use:

FROM ubuntu:22.04

# Установить системные зависимости
RUN apt-get update && apt-get install -y \
    xvfb x11-utils xdotool scrot fluxbox \
    firefox-esr python3 python3-pip \
    && rm -rf /var/lib/apt/lists/*

# Создать непривилегированного пользователя для агента
RUN useradd -m -s /bin/bash agent

# Переключиться на непривилегированного пользователя
USER agent
WORKDIR /home/agent

# Установить Python-зависимости
COPY --chown=agent:agent requirements.txt .
RUN pip3 install --no-cache-dir -r requirements.txt

# Скопировать код агента
COPY --chown=agent:agent agent.py .

ENV DISPLAY=:99

CMD ["bash", "-c", "Xvfb :99 -screen 0 1280x800x24 & sleep 1 && python3 agent.py"]

Запустите со строгими ограничениями безопасности:

docker run -d \
  --name computer-use-agent \
  --network none \
  --read-only \
  --memory 2g \
  --cpus 2 \
  --tmpfs /tmp \
  --tmpfs /home/agent \
  -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
  -e AGENT_TASK="Open Firefox and navigate to https://example.com" \
  computer-use-sandbox:latest

Стратегии изоляции безопасности

1. Сетевая изоляция:

# Нет сетевого доступа по умолчанию
--network none

# Allowlist специфических доменов через прокси
--network custom-net \
-e HTTP_PROXY=http://filtering-proxy:3128

2. Ограничения файловой системы:

# Read-only корневая файловая система
--read-only

# Tmpfs для записываемых директорий
--tmpfs /tmp \
--tmpfs /home/agent \
--tmpfs /var/run

3. Лимиты ресурсов:

# Предотвратить истощение ресурсов
--memory 2g \
--memory-swap 2g \
--cpus 2 \
--pids-limit 100

4. Шлюзы подтверждения человеком:

DANGEROUS_ACTIONS = {
    "submit": "Form submission",
    "purchase": "Financial transaction",
    "delete": "Data deletion",
    "send": "Communication sent",
}

def requires_confirmation(action: dict, screenshot_b64: str) -> bool:
    """Check if action requires human confirmation."""
    # Simple keyword check (could add OCR for button text)
    for keyword in DANGEROUS_ACTIONS:
        if keyword in str(action).lower():
            return True
    return False

def get_human_confirmation(action: dict, reason: str) -> bool:
    """Ask human to confirm dangerous action."""
    print(f"\n[CONFIRMATION REQUIRED] {reason}")
    print(f"Action: {action}")
    response = input("Proceed? (yes/no): ").strip().lower()
    return response in ("yes", "y")

5. E2B Desktop Sandbox:

Для многотенантных production-развертываний используйте E2B's управляемые Firecracker-based microVMs:

from e2b_desktop import Desktop

async def run_with_e2b_sandbox(task: str) -> str:
    """Run computer use task in E2B Desktop sandbox."""
    async with Desktop() as desktop:
        screenshot = await desktop.screenshot()

        messages = [{"role": "user", "content": task}]

        for iteration in range(30):
            response = client.beta.messages.create(
                model="claude-opus-4-6",
                max_tokens=4096,
                tools=[{
                    "type": "computer_20251124",
                    "name": "computer",
                    "display_width_px": 1280,
                    "display_height_px": 800,
                }],
                messages=messages,
                betas=["computer-use-2025-11-24"],
            )

            if response.stop_reason == "end_turn":
                break

            for block in response.content:
                if block.type != "tool_use":
                    continue

                action = block.input
                action_type = action["action"]

                if action_type == "left_click":
                    x, y = action["coordinate"]
                    await desktop.left_click(x, y)
                elif action_type == "type":
                    await desktop.type(action["text"])
                elif action_type == "key":
                    await desktop.key(action["key"])

                screenshot = await desktop.screenshot()

        return "Task completed in E2B sandbox."

Производительность и бенчмарки

Примечание: Приведённые ниже цифры являются иллюстративными оценками на основе типичных production-конфигураций, а не измерениями конкретной системы.

Характеристики задержки

Computer use включает несколько последовательных операций, которые способствуют общей задержке:

• Захват скриншота: 50-200ms в зависимости от разрешения и сжатия
• Передача по сети: 100-500ms для загрузки скриншота в API Anthropic
• Inference модели: 2-10 секунд для анализа Claude скриншота и планирования действия (варьируется в зависимости от бюджета thinking и сложности задачи)
• Выполнение действия: 50-300ms для операций мыши/клавиатуры
• Задержка обновления UI: 100-1000ms для ответа приложений на действия

Типичная end-to-end задержка за итерацию: 3-12 секунд от выполнения действия до следующего решения о действии.

Оценки стоимости

Затраты на токены computer use состоят из overhead системного промпта, определений инструментов, токенов изображения скриншота и текстовых токенов:

• Overhead системного промпта: ~466-499 токенов (добавляется автоматически)
• Определение инструмента computer use: 735 токенов
• Токены скриншота: (width × height) / 750 за изображение
  • Скриншот 1280×800: ~1,365 токенов
  • Скриншот 1920×1080 (уменьшен до ~1330×864): ~1,528 токенов
• Текстовые токены: ~1,500-3,000 за итерацию (история + рассуждения + действие)

Типичная стоимость итерации с Claude Opus 4.6 (разрешение 1280×800):

• Input: ~3,500 токенов (скриншот + история + системный промпт) × $15/MTok = $0.0525
• Output: ~500 токенов × $75/MTok = $0.0375
• Total за итерацию: ~$0.09

Задача в 20 итераций: ~$1.80 затрат API с Opus 4.6.

Стратегии снижения стоимости:

• Используйте Claude Sonnet 4.6 для более простых задач (примерно 1/5 стоимости Opus 4.6)
• Сократите разрешение скриншота (1024×768 вместо 1920×1080)
• Используйте JPEG сжатие с quality=75 для снижения количества токенов изображения
• Реализуйте кеширование для повторяющихся скриншотов (если применимо)
• Группируйте независимые действия когда возможно

Ограничения пропускной способности

Computer use по своей природе последовательный — каждое действие зависит от наблюдения результата предыдущего действия. Это ограничивает пропускную способность в сравнении с параллельной API-автоматизацией:

• Последовательное выполнение: Не может параллелизировать внутри одной задачи
• Ограничения частоты API: Применяются стандартные ограничения частоты Anthropic
• Отзывчивость UI: Некоторые приложения требуют секунды для обработки действий

Для сценариев высокой пропускной способности, требующих сотни операций в минуту, traditional automation (Playwright, Selenium) остается более уместным.

Производительность бенчмарков

Claude Opus 4.6 достигает state-of-the-art результатов на бенчмарках computer use:

• OSWorld: 72,7% завершение задач (в сравнении с 66,3% для Opus 4.5)
• WebArena: State-of-the-art среди одноагентных систем для автономной навигации по веб

Эти бенчмарки измеряют завершение задач в реальном мире во множественном разнообразии десктопных и веб-приложений, включая многошаговые рабочие потоки, требующие навигации, заполнения форм, управления файлами и взаимодействия с приложениями.