Uso do computador (beta)

Claude 3.7 Sonnet e Claude 3.5 Sonnet (novo) são capazes de interagir com ferramentas que podem manipular um ambiente de desktop do computador. Claude 3.7 Sonnet introduz ferramentas adicionais e permite que você habilite o pensamento, dando mais insights sobre o processo de raciocínio do modelo.

Aqui está um exemplo de como fornecer ferramentas de uso do computador ao Claude usando a API de Mensagens:

​

Como funciona o uso do computador

Nos referimos à repetição dos passos 3 e 4 sem entrada do usuário como o “loop do agente” - ou seja, Claude respondendo com uma requisição de uso de ferramenta e sua aplicação respondendo ao Claude com os resultados da avaliação dessa requisição.

​

O ambiente de computação

O uso do computador requer um ambiente de computação isolado onde o Claude pode interagir com segurança com aplicativos e a web. Este ambiente inclui:

1. Display virtual: Um servidor de display X11 virtual (usando Xvfb) que renderiza a interface desktop que o Claude verá através de capturas de tela e controlará com ações de mouse/teclado.

2. Ambiente desktop: Uma UI leve com gerenciador de janelas (Mutter) e painel (Tint2) rodando no Linux, que fornece uma interface gráfica consistente para o Claude interagir.

3. Aplicativos: Aplicativos Linux pré-instalados como Firefox, LibreOffice, editores de texto e gerenciadores de arquivos que o Claude pode usar para completar tarefas.

4. Implementações de ferramentas: Código de integração que traduz as requisições abstratas de ferramentas do Claude (como “mover mouse” ou “capturar tela”) em operações reais no ambiente virtual.

5. Loop do agente: Um programa que gerencia a comunicação entre o Claude e o ambiente, enviando as ações do Claude para o ambiente e retornando os resultados (capturas de tela, saídas de comandos) de volta ao Claude.

Quando você usa o uso do computador, o Claude não se conecta diretamente a este ambiente. Em vez disso, sua aplicação:

1. Recebe as requisições de uso de ferramenta do Claude
2. Traduz elas em ações no seu ambiente de computação
3. Captura os resultados (capturas de tela, saídas de comandos, etc.)
4. Retorna estes resultados ao Claude

Para segurança e isolamento, a implementação de referência executa tudo isso dentro de um container Docker com mapeamentos de porta apropriados para visualizar e interagir com o ambiente.

​

Como implementar o uso do computador

​

Comece com nossa implementação de referência

Nós construímos uma implementação de referência que inclui tudo que você precisa para começar rapidamente com o uso do computador:

• Um ambiente containerizado adequado para uso do computador com o Claude
• Implementações das ferramentas de uso do computador
• Um loop de agente que interage com a API da Anthropic e executa as ferramentas de uso do computador
• Uma interface web para interagir com o container, loop de agente e ferramentas.

​

Entendendo o loop multi-agente

O núcleo do uso do computador é o “loop do agente” - um ciclo onde o Claude requisita ações de ferramentas, sua aplicação as executa e retorna resultados ao Claude. Aqui está um exemplo simplificado:

async def sampling_loop(
    *,
    model: str,
    messages: list[dict],
    api_key: str,
    max_tokens: int = 4096,
    tool_version: str,
    thinking_budget: int | None = None,
    max_iterations: int = 10,  # Adiciona limite de iteração para prevenir loops infinitos
):
    """
    Um loop de agente simples para interações de uso do computador do Claude.
    
    Esta função gerencia o vai-e-vem entre:
    1. Enviando mensagens do usuário ao Claude
    2. Claude requisitando usar ferramentas
    3. Sua app executando essas ferramentas
    4. Enviando resultados das ferramentas de volta ao Claude
    """
    # Configura ferramentas e parâmetros da API
    client = Anthropic(api_key=api_key)
    beta_flag = "computer-use-2025-01-24" if "20250124" in tool_version else "computer-use-2024-10-22"
    
    # Configura ferramentas - você deve já tê-las inicializado em outro lugar
    tools = [
        {"type": f"computer_{tool_version}", "name": "computer", "display_width_px": 1024, "display_height_px": 768},
        {"type": f"text_editor_{tool_version}", "name": "str_replace_editor"},
        {"type": f"bash_{tool_version}", "name": "bash"}
    ]
    
    # Loop principal do agente (com limite de iteração para prevenir custos inesperados de API)
    iterations = 0
    while True and iterations < max_iterations:
        iterations += 1
        # Configura parâmetro opcional de pensamento (para Claude 3.7 Sonnet)
        thinking = None
        if thinking_budget:
            thinking = {"type": "enabled", "budget_tokens": thinking_budget}
            
        # Chama a API do Claude
        response = client.beta.messages.create(
            model=model,
            max_tokens=max_tokens,
            messages=messages,
            tools=tools,
            betas=[beta_flag],
            thinking=thinking
        )
        
        # Adiciona a resposta do Claude ao histórico da conversa
        response_content = response.content
        messages.append({"role": "assistant", "content": response_content})
        
        # Verifica se o Claude usou alguma ferramenta
        tool_results = []
        for block in response_content:
            if block.type == "tool_use":
                # Em uma app real, você executaria a ferramenta aqui
                # Por exemplo: result = run_tool(block.name, block.input)
                result = {"result": "Ferramenta executada com sucesso"}
                
                # Formata o resultado para o Claude
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result
                })
        
        # Se nenhuma ferramenta foi usada, Claude terminou - retorna as mensagens finais
        if not tool_results:
            return messages
            
        # Adiciona resultados das ferramentas às mensagens para a próxima iteração com o Claude
        messages.append({"role": "user", "content": tool_results})

O loop continua até que o Claude responda sem requisitar nenhuma ferramenta (conclusão da tarefa) ou o limite máximo de iteração seja atingido. Esta salvaguarda previne potenciais loops infinitos que poderiam resultar em custos inesperados de API.

Recomendamos experimentar a implementação de referência antes de ler o resto desta documentação.

​

Otimize o desempenho do modelo com prompting

Aqui estão algumas dicas sobre como obter as melhores saídas de qualidade:

1. Especifique tarefas simples e bem definidas e forneça instruções explícitas para cada passo.
2. O Claude às vezes assume resultados de suas ações sem verificar explicitamente seus resultados. Para prevenir isso você pode fazer o prompt do Claude com Após cada passo, tire uma captura de tela e avalie cuidadosamente se você alcançou o resultado correto. Mostre explicitamente seu pensamento: "Eu avaliei o passo X..." Se não estiver correto, tente novamente. Apenas quando você confirmar que um passo foi executado corretamente deve seguir para o próximo.
3. Alguns elementos de UI (como dropdowns e barras de rolagem) podem ser complicados para o Claude manipular usando movimentos do mouse. Se você experimentar isso, tente fazer o prompt do modelo para usar atalhos de teclado.
4. Para tarefas repetitivas ou interações de UI, inclua capturas de tela de exemplo e chamadas de ferramentas de resultados bem-sucedidos em seu prompt.
5. Se você precisar que o modelo faça login, forneça o nome de usuário e senha em seu prompt dentro de tags xml como <robot_credentials>. Usar o uso do computador dentro de aplicações que requerem login aumenta o risco de resultados ruins como resultado de injeção de prompt. Por favor, revise nosso guia sobre mitigação de injeções de prompt antes de fornecer credenciais de login ao modelo.

​

Prompts do sistema

Quando uma das ferramentas definidas pela Anthropic é requisitada via API da Anthropic, um prompt do sistema específico para uso do computador é gerado. É similar ao prompt do sistema de uso de ferramenta mas começa com:

Você tem acesso a um conjunto de funções que pode usar para responder à pergunta do usuário. Isso inclui acesso a um ambiente de computação isolado. Você NÃO tem atualmente a capacidade de inspecionar arquivos ou interagir com recursos externos, exceto invocando as funções abaixo.

Como com o uso regular de ferramentas, o campo system_prompt fornecido pelo usuário ainda é respeitado e usado na construção do prompt do sistema combinado.

​

Entenda as ferramentas definidas pela Anthropic

Nós fornecemos um conjunto de ferramentas que permitem que o Claude use computadores efetivamente. Ao especificar uma ferramenta definida pela Anthropic, os campos description e tool_schema não são necessários ou permitidos.

Nós fornecemos um conjunto de ferramentas definidas pela Anthropic, com cada ferramenta tendo versões otimizadas tanto para o Claude 3.5 Sonnet (novo) quanto para o Claude 3.7 Sonnet:

O campo type identifica a ferramenta e seus parâmetros para fins de validação, o campo name é o nome da ferramenta exposto ao modelo.

Se você quiser fazer o prompt do modelo para usar uma dessas ferramentas, você pode se referir explicitamente à ferramenta pelo campo name. O campo name deve ser único dentro da lista de ferramentas; você não pode definir uma ferramenta com o mesmo nome de uma ferramenta definida pela Anthropic na mesma chamada de API.

Use um mouse e teclado para interagir com um computador, e tire capturas de tela.
* Esta é uma interface para uma GUI desktop. Você não tem acesso a um terminal ou menu de aplicativos. Você deve clicar em ícones da área de trabalho para iniciar aplicativos.
* Alguns aplicativos podem levar tempo para iniciar ou processar ações, então você pode precisar esperar e tirar capturas de tela sucessivas para ver os resultados de suas ações. Por exemplo, se você clicar no Firefox e uma janela não abrir, tente tirar outra captura de tela.
* A resolução da tela é {{ display_width_px }}x{{ display_height_px }}.
* O número do display é {{ display_number }}
* Sempre que você pretender mover o cursor para clicar em um elemento como um ícone, você deve consultar uma captura de tela para determinar as coordenadas do elemento antes de mover o cursor.
* Se você tentou clicar em um programa ou link mas ele falhou em carregar, mesmo depois de esperar, tente ajustar a posição do seu cursor para que a ponta do cursor caia visualmente sobre o elemento que você quer clicar.
* Certifique-se de clicar em quaisquer botões, links, ícones, etc com a ponta do cursor no centro do elemento. Não clique em caixas em suas bordas a menos que seja solicitado.

{
    "properties": {
        "action": {
            "description": "A ação a executar. As ações disponíveis são:\n"
            "* `key`: Pressiona uma tecla ou combinação de teclas no teclado.\n"
            "  - Isso suporta a sintaxe `key` do xdotool.\n"
            '  - Exemplos: "a", "Return", "alt+Tab", "ctrl+s", "Up", "KP_0" (para a tecla 0 do teclado numérico).\n'
            "* `hold_key`: Mantém pressionada uma tecla ou múltiplas teclas por uma duração especificada (em segundos). Suporta a mesma sintaxe que `key`.\n"
            "* `type`: Digite uma string de texto no teclado.\n"
            "* `cursor_position`: Obtém a coordenada atual (x, y) em pixels do cursor na tela.\n"
            "* `mouse_move`: Move o cursor para uma coordenada (x, y) em pixels especificada na tela.\n"
            "* `left_mouse_down`: Pressiona o botão esquerdo do mouse.\n"
            "* `left_mouse_up`: Solta o botão esquerdo do mouse.\n"
            "* `left_click`: Clica o botão esquerdo do mouse na coordenada (x, y) em pixels especificada na tela. Você também pode incluir uma combinação de teclas para manter pressionada enquanto clica usando o parâmetro `text`.\n"
            "* `left_click_drag`: Clica e arrasta o cursor de `start_coordinate` para uma coordenada (x, y) em pixels especificada na tela.\n"
            "* `right_click`: Clica o botão direito do mouse na coordenada (x, y) em pixels especificada na tela.\n"
            "* `middle_click`: Clica o botão do meio do mouse na coordenada (x, y) em pixels especificada na tela.\n"
            "* `double_click`: Clica duas vezes o botão esquerdo do mouse na coordenada (x, y) em pixels especificada na tela.\n"
            "* `triple_click`: Clica três vezes o botão esquerdo do mouse na coordenada (x, y) em pixels especificada na tela.\n"
            "* `scroll`: Rola a tela em uma direção especificada por uma quantidade especificada de cliques da roda de rolagem, na coordenada (x, y) em pixels especificada. NÃO use PageUp/PageDown para rolar.\n"
            "* `wait`: Espera por uma duração especificada (em segundos).\n"
            "* `screenshot`: Tira uma captura de tela da tela.",
            "enum": [
                "key",
                "hold_key",
                "type",
                "cursor_position",
                "mouse_move",
                "left_mouse_down",
                "left_mouse_up",
                "left_click",
                "left_click_drag",
                "right_click",
                "middle_click",
                "double_click",
                "triple_click",
                "scroll",
                "wait",
                "screenshot",
            ],
            "type": "string",
        },
        "coordinate": {
            "description": "(x, y): As coordenadas x (pixels da borda esquerda) e y (pixels da borda superior) para mover o mouse para. Requerido apenas por `action=mouse_move` e `action=left_click_drag`.",
            "type": "array",
        },
        "duration": {
            "description": "A duração para manter a tecla pressionada. Requerido apenas por `action=hold_key` e `action=wait`.",
            "type": "integer",
        },
        "scroll_amount": {
            "description": "O número de 'cliques' para rolar. Requerido apenas por `action=scroll`.",
            "type": "integer",
        },
        "scroll_direction": {
            "description": "A direção para rolar a tela. Requerido apenas por `action=scroll`.",
            "enum": ["up", "down", "left", "right"],
            "type": "string",
        },
        "start_coordinate": {
            "description": "(x, y): As coordenadas x (pixels da borda esquerda) e y (pixels da borda superior) para começar o arrasto. Requerido apenas por `action=left_click_drag`.",
            "type": "array",
        },
        "text": {
            "description": "Requerido apenas por `action=type`, `action=key`, e `action=hold_key`. Também pode ser usado por ações de clique ou rolagem para manter teclas pressionadas enquanto clica ou rola.",
            "type": "string",
        },
    },
    "required": ["action"],
    "type": "object",
}

{
    "properties": {
        "action": {
            "description": """A ação a executar. As ações disponíveis são:
                * `key`: Pressiona uma tecla ou combinação de teclas no teclado.
                  - Isso suporta a sintaxe `key` do xdotool.
                  - Exemplos: "a", "Return", "alt+Tab", "ctrl+s", "Up", "KP_0" (para a tecla 0 do teclado numérico).
                * `type`: Digite uma string de texto no teclado.
                * `cursor_position`: Obtém a coordenada atual (x, y) em pixels do cursor na tela.
                * `mouse_move`: Move o cursor para uma coordenada (x, y) em pixels especificada na tela.
                * `left_click`: Clica o botão esquerdo do mouse.
                * `left_click_drag`: Clica e arrasta o cursor para uma coordenada (x, y) em pixels especificada na tela.
                * `right_click`: Clica o botão direito do mouse.
                * `middle_click`: Clica o botão do meio do mouse.
                * `double_click`: Clica duas vezes o botão esquerdo do mouse.
                * `screenshot`: Tira uma captura de tela da tela.""",
            "enum": [
                "key",
                "type",
                "mouse_move",
                "left_click",
                "left_click_drag",
                "right_click",
                "middle_click",
                "double_click",
                "screenshot",
                "cursor_position",
            ],
            "type": "string",
        },
        "coordinate": {
            "description": "(x, y): As coordenadas x (pixels da borda esquerda) e y (pixels da borda superior) para mover o mouse para. Requerido apenas por `action=mouse_move` e `action=left_click_drag`.",
            "type": "array",
        },
        "text": {
            "description": "Requerido apenas por `action=type` e `action=key`.",
            "type": "string",
        },
    },
    "required": ["action"],
    "type": "object",
}

Ferramenta de edição personalizada para visualizar, criar e editar arquivos
* O estado é persistente entre chamadas de comando e discussões com o usuário
* Se `path` é um arquivo, `view` exibe o resultado de aplicar `cat -n`. Se `path` é um diretório, `view` lista arquivos e diretórios não ocultos até 2 níveis de profundidade
* O comando `create` não pode ser usado se o `path` especificado já existir como um arquivo
* Se um `command` gera uma saída longa, ela será truncada e marcada com `<response clipped>`
* O comando `undo_edit` reverterá a última edição feita no arquivo em `path`

Notas para usar o comando `str_replace`:
* O parâmetro `old_str` deve corresponder EXATAMENTE a uma ou mais linhas consecutivas do arquivo original. Fique atento aos espaços em branco!
* Se o parâmetro `old_str` não for único no arquivo, a substituição não será realizada. Certifique-se de incluir contexto suficiente em `old_str` para torná-lo único
* O parâmetro `new_str` deve conter as linhas editadas que devem substituir o `old_str`

{
    "properties": {
        "command": {
            "description": "Os comandos para executar. Opções permitidas são: `view`, `create`, `str_replace`, `insert`, `undo_edit`.",
            "enum": ["view", "create", "str_replace", "insert", "undo_edit"],
            "type": "string",
        },
        "file_text": {
            "description": "Parâmetro obrigatório do comando `create`, com o conteúdo do arquivo a ser criado.",
            "type": "string",
        },
        "insert_line": {
            "description": "Parâmetro obrigatório do comando `insert`. O `new_str` será inserido APÓS a linha `insert_line` de `path`.",
            "type": "integer",
        },
        "new_str": {
            "description": "Parâmetro opcional do comando `str_replace` contendo a nova string (se não fornecido, nenhuma string será adicionada). Parâmetro obrigatório do comando `insert` contendo a string a ser inserida.",
            "type": "string",
        },
        "old_str": {
            "description": "Parâmetro obrigatório do comando `str_replace` contendo a string em `path` para substituir.",
            "type": "string",
        },
        "path": {
            "description": "Caminho absoluto para arquivo ou diretório, por exemplo `/repo/file.py` ou `/repo`.",
            "type": "string",
        },
        "view_range": {
            "description": "Parâmetro opcional do comando `view` quando `path` aponta para um arquivo. Se nenhum for fornecido, o arquivo completo é mostrado. Se fornecido, o arquivo será mostrado no intervalo de números de linha indicado, por exemplo [11, 12] mostrará as linhas 11 e 12. Indexação começando em 1. Definir `[start_line, -1]` mostra todas as linhas de `start_line` até o final do arquivo.",
            "items": {"type": "integer"},
            "type": "array",
        },
    },
    "required": ["command", "path"],
    "type": "object",
}

Executa comandos em um shell bash
* Ao invocar esta ferramenta, o conteúdo do parâmetro "command" NÃO precisa ser escapado em XML.
* Você tem acesso a um espelho de pacotes linux e python comuns via apt e pip.
* O estado é persistente entre chamadas de comando e discussões com o usuário.
* Para inspecionar um intervalo particular de linhas de um arquivo, por exemplo linhas 10-25, tente 'sed -n 10,25p /caminho/para/o/arquivo'.
* Por favor evite comandos que possam produzir uma quantidade muito grande de saída.
* Por favor execute comandos de longa duração em segundo plano, por exemplo 'sleep 10 &' ou inicie um servidor em segundo plano.

{
    "properties": {
        "command": {
            "description": "O comando bash para executar. Obrigatório a menos que a ferramenta esteja sendo reiniciada.",
            "type": "string",
        },
        "restart": {
            "description": "Especificar true irá reiniciar esta ferramenta. Caso contrário, deixe isso não especificado.",
            "type": "boolean",
        },
    }
}

​

Habilite a capacidade de pensamento no Claude 3.7 Sonnet

O Claude 3.7 Sonnet introduz uma nova capacidade de “pensamento” que permite que você veja o processo de raciocínio do modelo enquanto ele trabalha em tarefas complexas. Este recurso ajuda você a entender como o Claude está abordando um problema e pode ser particularmente valioso para depuração ou propósitos educacionais.

Para habilitar o pensamento, adicione um parâmetro thinking à sua requisição da API:

"thinking": {
  "type": "enabled",
  "budget_tokens": 1024
}

O parâmetro budget_tokens especifica quantos tokens o Claude pode usar para pensar. Isso é subtraído do seu orçamento geral de max_tokens.

Quando o pensamento está habilitado, o Claude retornará seu processo de raciocínio como parte da resposta, o que pode ajudar você a:

1. Entender o processo de tomada de decisão do modelo
2. Identificar potenciais problemas ou equívocos
3. Aprender com a abordagem do Claude para resolução de problemas
4. Obter mais visibilidade em operações complexas de múltiplos passos

Aqui está um exemplo de como a saída do pensamento pode parecer:

[Pensando]
Eu preciso salvar uma foto de um gato na área de trabalho. Deixe-me dividir isso em passos:

1. Primeiro, vou tirar uma captura de tela para ver o que está na área de trabalho
2. Então vou procurar um navegador web para buscar imagens de gatos
3. Depois de encontrar uma imagem adequada, vou precisar salvá-la na área de trabalho

Deixe-me começar tirando uma captura de tela para ver o que está disponível...

​

Combine uso do computador com outras ferramentas

Você pode combinar uso regular de ferramentas com as ferramentas definidas pela Anthropic para uso do computador.

​

Construa um ambiente personalizado de uso do computador

A implementação de referência é destinada a ajudar você a começar com o uso do computador. Ela inclui todos os componentes necessários para que o Claude use um computador. No entanto, você pode construir seu próprio ambiente para uso do computador para atender às suas necessidades. Você precisará de:

• Um ambiente virtualizado ou containerizado adequado para uso do computador com o Claude
• Uma implementação de pelo menos uma das ferramentas definidas pela Anthropic para uso do computador
• Um loop de agente que interage com a API da Anthropic e executa os resultados de tool_use usando suas implementações de ferramentas
• Uma API ou UI que permite entrada do usuário para iniciar o loop de agente

​

Entenda as limitações do uso do computador

A funcionalidade de uso do computador está em beta. Embora as capacidades do Claude sejam de ponta, os desenvolvedores devem estar cientes de suas limitações:

1. Latência: a latência atual do uso do computador para interações humano-IA pode ser muito lenta comparada a ações regulares de computador direcionadas por humanos. Recomendamos focar em casos de uso onde a velocidade não é crítica (por exemplo, coleta de informações em segundo plano, teste automatizado de software) em ambientes confiáveis.
2. Precisão e confiabilidade da visão computacional: o Claude pode cometer erros ou alucinar ao gerar coordenadas específicas ao gerar ações. O Claude 3.7 Sonnet introduz a capacidade de pensamento que pode ajudar você a entender o raciocínio do modelo e identificar potenciais problemas.
3. Precisão e confiabilidade na seleção de ferramentas: o Claude pode cometer erros ou alucinar ao selecionar ferramentas ao gerar ações ou tomar ações inesperadas para resolver problemas. Além disso, a confiabilidade pode ser menor ao interagir com aplicativos de nicho ou múltiplos aplicativos ao mesmo tempo. Recomendamos que os usuários façam o prompt do modelo cuidadosamente ao solicitar tarefas complexas.
4. Confiabilidade da rolagem: Embora o Claude 3.5 Sonnet (novo) tivesse limitações com rolagem, o Claude 3.7 Sonnet introduz ações dedicadas de rolagem com controle de direção que melhora a confiabilidade. O modelo agora pode explicitamente rolar em qualquer direção (cima/baixo/esquerda/direita) por uma quantidade especificada.
5. Interação com planilhas: Cliques do mouse para interação com planilhas melhoraram no Claude 3.7 Sonnet com a adição de ações de controle do mouse mais precisas como left_mouse_down, left_mouse_up, e novo suporte a teclas modificadoras. A seleção de células pode ser mais confiável usando estes controles refinados e combinando teclas modificadoras com cliques.
6. Criação de conta e geração de conteúdo em plataformas sociais e de comunicação: Embora o Claude visite websites, estamos limitando sua capacidade de criar contas ou gerar e compartilhar conteúdo ou de outra forma se envolver em personificação humana em websites e plataformas de mídia social. Podemos atualizar esta capacidade no futuro.
7. Vulnerabilidades: Vulnerabilidades como jailbreaking ou injeção de prompt podem persistir em sistemas de IA de fronteira, incluindo a API beta de uso do computador. Em algumas circunstâncias, o Claude seguirá comandos encontrados no conteúdo, às vezes mesmo em conflito com as instruções do usuário. Por exemplo, instruções do Claude em páginas web ou contidas em imagens podem substituir instruções ou fazer com que o Claude cometa erros. Recomendamos: a. Limitar o uso do computador a ambientes confiáveis como máquinas virtuais ou containers com privilégios mínimos b. Evitar dar acesso de uso do computador a contas ou dados sensíveis sem supervisão estrita c. Informar os usuários finais sobre riscos relevantes e obter seu consentimento antes de habilitar ou solicitar permissões necessárias para recursos de uso do computador em suas aplicações
8. Ações inadequadas ou ilegais: De acordo com os termos de serviço da Anthropic, você não deve empregar o uso do computador para violar quaisquer leis ou nossa Política de Uso Aceitável.

Sempre revise e verifique cuidadosamente as ações e logs de uso do computador do Claude. Não use o Claude para tarefas que requerem precisão perfeita ou informações sensíveis do usuário sem supervisão humana.

​

Preços

Como um subconjunto de requisições de uso de ferramentas, requisições de uso do computador são precificadas da mesma forma que qualquer outra requisição da API do Claude.

Nós também incluímos automaticamente um prompt do sistema especial para o modelo, que habilita o uso do computador.

Além dos tokens base, os seguintes tokens de entrada adicionais são necessários para as ferramentas definidas pela Anthropic:

Se você habilitar o pensamento com o Claude 3.7 Sonnet, os tokens usados para pensar serão contados contra seu orçamento de max_tokens baseado no budget_tokens que você especificar no parâmetro thinking.