E se você pudesse dizer para uma IA “abre o Firefox, navega para um site, preenche o formulário e salva o resultado” — e ela realmente fizesse isso? Não através de um script Selenium frágil. Não através de uma integração de API personalizada. Apenas… olhando para a tela e usando o mouse e o teclado como um humano faria.

É exatamente isso que o computer use tool do Claude faz.

O Que É Computer Use?

Computer use é um recurso de API em beta que permite ao Claude interagir com ambientes desktop através de:

Captura de screenshot — Claude vê o que está na tela
Controle do mouse — cliques, arrastar, rolar
Input de teclado — digitar texto, pressionar atalhos
Automação desktop — interagir com qualquer aplicação

A palavra-chave é qualquer. Ao contrário da automação tradicional (Selenium para browsers, AppleScript para macOS), Claude não precisa de APIs especiais ou seletores de elementos. Ele olha para os pixels na tela e decide onde clicar. Assim como você faz.

Como Funciona (O Agent Loop)

Computer use segue um ciclo simples:

Você envia uma tarefa para Claude — “Salva uma foto de um gato no desktop”
Claude solicita uma ação de ferramenta — “Tira um screenshot”
Seu app executa — captura a tela, retorna a imagem
Claude analisa e solicita a próxima ação — “Clica nas coordenadas (500, 300)”
Repete até a tarefa estar concluída

Esse ciclo se chama agent loop. Claude continua solicitando ações (screenshot, clique, digitação, rolagem) e sua aplicação continua executando-as, até Claude determinar que a tarefa está completa.

Aqui está a chamada API mínima para começar:

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    tools=[
        {
            "type": "computer_20251124",
            "name": "computer",
            "display_width_px": 1024,
            "display_height_px": 768,
            "display_number": 1,
        },
        {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"},
        {"type": "bash_20250124", "name": "bash"},
    ],
    messages=[{
        "role": "user",
        "content": "Save a picture of a cat to my desktop."
    }],
    betas=["computer-use-2025-11-24"],
)

O header beta "computer-use-2025-11-24" é obrigatório. As três ferramentas (computador, editor de texto, bash) trabalham juntas para dar ao Claude controle total sobre o ambiente.

Ações Disponíveis

O computer use tool suporta um rico conjunto de interações:

Ações Básicas

screenshot — captura o display atual
left_click — clica nas coordenadas [x, y]
type — digita uma string de texto
key — pressiona uma tecla ou combinação (ex.: ctrl+s, alt+tab)
mouse_move — move o cursor

Ações Avançadas (Modelos Claude 4.x)

scroll — rolagem em qualquer direção com controle de quantidade
left_click_drag — clica e arrasta entre coordenadas
right_click, middle_click — botões adicionais do mouse
double_click, triple_click — múltiplos cliques
hold_key — mantém uma tecla pressionada por uma duração
wait — pausa entre ações

Adição Mais Recente: Zoom

Disponível no Claude Opus 4.6, Sonnet 4.6 e Opus 4.5:

zoom — inspeciona uma região específica da tela em resolução completa

Particularmente útil quando Claude precisa ler texto pequeno ou identificar detalhes finos de UI.

O Ambiente de Computação

Claude não se conecta diretamente ao seu computador. Você precisa fornecer um ambiente sandbox — tipicamente um container Docker executando:

Display virtual — Xvfb (X Virtual Framebuffer) renderiza o desktop
Ambiente desktop — um gerenciador de janelas leve como Mutter
Aplicações — Firefox, LibreOffice, gerenciadores de arquivo, etc.
Implementações de ferramentas — código que traduz as solicitações de Claude em operações reais de mouse/teclado

A Anthropic fornece uma implementação de referência com tudo isso pré-configurado no Docker. É a maneira mais rápida de começar.

Construindo o Agent Loop

Aqui está um agent loop simplificado que lida com o vai-e-vem:

async def agent_loop(task: str, max_iterations: int = 10):
    client = anthropic.Anthropic()
    messages = [{"role": "user", "content": task}]

    tools = [
        {
            "type": "computer_20251124",
            "name": "computer",
            "display_width_px": 1024,
            "display_height_px": 768,
        },
        {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"},
        {"type": "bash_20250124", "name": "bash"},
    ]

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

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

        # Extract tool calls
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })

        if not tool_results:
            return messages  # Task complete

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

A função execute_tool é onde você conecta a captura real de tela, cliques do mouse e input do teclado ao seu ambiente de computação.

Escalamento de Coordenadas: A Armadilha

A API limita imagens a um máximo de 1568px no lado mais longo. Se seu display é maior (digamos, 1512x982), os screenshots são reduzidos — mas Claude retorna coordenadas baseadas na imagem menor.

Você precisa escalar as coordenadas de volta para cima:

import math

def get_scale_factor(width, height):
    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)

scale = get_scale_factor(1512, 982)

# When Claude says "click at (450, 300)", scale it up:
def execute_click(x, y):
    screen_x = x / scale
    screen_y = y / scale
    perform_click(screen_x, screen_y)

Pular esse passo significa que os cliques de Claude vão errar os alvos. Esse é o bug de implementação mais comum.

Dicas de Prompting para Melhores Resultados

Computer use funciona melhor com prompts claros e estruturados:

Seja específico. “Abre o Firefox, vai para example.com e clica no botão Login” funciona melhor do que “faz login no site.”
Peça ao Claude para verificar. Adicione isso ao seu prompt: “Após cada etapa, tira um screenshot e avalia se você atingiu o resultado correto. Só avance quando confirmado.”
Use atalhos de teclado. Dropdowns e barras de rolagem podem ser difíceis de clicar. Diga ao Claude para usar Tab, Enter e teclas de seta em vez disso.
Forneça exemplos. Para tarefas repetíveis, inclua screenshots de exemplo e chamadas de ferramentas esperadas no seu prompt.
Use tags XML para credenciais. Se Claude precisar fazer login, passe as credenciais em tags <robot_credentials>. Mas cuidado — os riscos de injeção de prompt são maiores quando Claude interage com conteúdo não confiável.

Segurança: Leve a Sério

Computer use tem riscos de segurança únicos:

Injeção de prompt através do conteúdo da tela. Claude lê tudo na tela. Uma página web maliciosa poderia exibir instruções que sobrescrevem seu prompt.
Ações autônomas. Claude pode clicar em links, aceitar diálogos ou navegar para longe de onde você pretendia.
Exposição de credenciais. Se Claude puder ver senhas ou tokens na tela, eles se tornam parte da conversa.

A Anthropic tem classificadores embutidos que sinalizam potenciais injeções de prompt em screenshots. Mas a melhor defesa é o isolamento:

Execute em uma VM dedicada ou container Docker com privilégios mínimos
Não dê acesso a contas sensíveis sem supervisão
Limite o acesso à internet a uma allowlist de domínios
Exija confirmação humana para ações consequentes (compras, criação de conta, etc.)

O Que Construir Com Ele

Computer use é melhor para tarefas onde a velocidade não é crítica mas a automação tem valor:

Testes automatizados — teste qualquer aplicação desktop, não apenas web apps
Coleta de dados — navegue em sites e extraia informações
Integração com sistemas legados — automatize fluxos de trabalho em apps sem API
Preenchimento de formulários — preencha formulários web em múltiplos sites
Fluxos de pesquisa — pesquise, leia e compile informações da web
QA e monitoramento — verifique se as UIs renderizam corretamente

Para fluxos de pesquisa e coleta de dados, ferramentas como o Save complementam bem o computer use — depois que Claude navega para uma página, converter para Markdown limpo dá a você conteúdo estruturado e pronto para IA em vez de screenshots brutos.

Limitações Atuais

Esteja ciente destas limitações da beta:

Latência. Cada ação requer uma chamada API, captura de screenshot e resposta. É mais lento do que um humano clicando.
Precisão visual. Claude pode ler mal texto pequeno ou identificar erroneamente elementos de UI. A nova ação zoom ajuda, mas não é perfeita.
Rolagem. Melhorou significativamente em versões recentes, mas interações de rolagem complexas ainda podem ser não confiáveis.
Planilhas. Seleção de células é complicada. Use navegação pelo teclado quando possível.
Sem criação de contas em plataformas sociais. Claude intencionalmente não cria contas ou se passa por humanos em redes sociais.

Preços

Computer use segue o preço padrão de uso de ferramentas:

Overhead do system prompt: 466-499 tokens
Definição de ferramenta: 735 tokens por ferramenta (para modelos Claude 4.x)
Screenshots: cobrados como tokens de visão (varia por resolução)
Cada chamada API no agent loop é uma solicitação cobrável separada

Para uma tarefa típica de 10 etapas, espere usar 15.000-50.000 tokens dependendo dos tamanhos dos screenshots e da complexidade das respostas.

Primeiros Passos

Experimente a implementação de referência. Clone anthropic-quickstarts, execute o container Docker e experimente.
Comece com tarefas simples. “Abre um editor de texto, digita Hello World, salva o arquivo.” Faça o agent loop funcionar antes de tentar fluxos de trabalho complexos.
Adicione guardrails. Defina limites de iteração. Valide coordenadas. Registre cada ação. Adicione confirmação humana para qualquer coisa irreversível.
Otimize seus prompts. Quanto melhores suas instruções, menos iterações Claude precisa — e menores são seus custos de tokens.

Computer use representa uma mudança fundamental no que é possível com APIs de IA. Em vez de construir integrações personalizadas para cada aplicação, você pode dar ao Claude a mesma interface que os humanos usam — uma tela, um mouse e um teclado — e deixá-lo descobrir o resto.

O futuro da automação não são mais APIs. É IA que pode usar as interfaces que já temos.