---
title: Esforço
url: https://platform.claude.com/docs/pt-BR/build-with-claude/effort
description: Controle quantos tokens Claude usa ao responder com o parâmetro effort, equilibrando a profundidade da resposta e a eficiência de tokens.
featureMetadata:
  status: ga
  zdr:
    eligibility: eligible
    note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
  supportedModels:
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-sonnet-4-6
    - claude-haiku-5-5
  supportedPlatforms:
    Claude API: ga
    Claude Platform on AWS: ga
    Amazon Bedrock: ga
    Google Cloud: ga
    Microsoft Foundry: ga
---

O parâmetro "effort" (esforço) permite que você controle quantos tokens Claude gasta ao responder a solicitações. Você pode equilibrar entre a profundidade da resposta e a eficiência de tokens com um único modelo. O parâmetro effort de nível superior está disponível em todos os modelos compatíveis, sem necessidade de cabeçalho beta. O [esforço por mensagem](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#change-effort-mid-conversation-beta) está em beta.

<Tip>
  Para saber como o esforço interage com o pensamento e qual controle usar, consulte [Pensamento e esforço](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking#thinking-and-effort). Onde o pensamento adaptativo está disponível, o esforço é a forma recomendada de controlar a profundidade do pensamento.
</Tip>

## Definir o nível de esforço

Defina `output_config.effort` na solicitação. O exemplo a seguir executa uma solicitação com esforço `medium` e imprime o texto da resposta.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "messages": [{
        "role": "user",
        "content": "Analyze the trade-offs between microservices and monolithic architectures"
      }],
      "output_config": {
        "effort": "medium"
      }
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 4096 \
    --output-config '{effort: medium}' \
    --message '{role: user, content: "Analyze the trade-offs between microservices and monolithic architectures"}' \
    --transform 'content.#(type=="text").text' \
    --raw-output
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Analyze the trade-offs between microservices and monolithic architectures",
          }
      ],
      output_config={"effort": "medium"},
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Analyze the trade-offs between microservices and monolithic architectures"
      }
    ],
    output_config: {
      effort: "medium"
    }
  });

  const textBlock = response.content.find(
    (block): block is Anthropic.TextBlock => block.type === "text"
  );
  console.log(textBlock?.text);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new() {
              Role = Role.User,
              Content = "Analyze the trade-offs between microservices and monolithic architectures"
          }
      ],
      OutputConfig = new OutputConfig
      {
          Effort = Effort.Medium
      }
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the trade-offs between microservices and monolithic architectures")),
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortMedium,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.messages.OutputConfig;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Analyze the trade-offs between microservices and monolithic architectures")
          .outputConfig(OutputConfig.builder()
              .effort(OutputConfig.Effort.MEDIUM)
              .build())
          .build();

      Message response = client.messages().create(params);
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Analyze the trade-offs between microservices and monolithic architectures']
      ],
      model: 'claude-opus-5-5',
      outputConfig: ['effort' => 'medium'],
  );

  foreach ($message->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Analyze the trade-offs between microservices and monolithic architectures" }
    ],
    output_config: {
      effort: "medium"
    }
  )

  message.content.each do |block|
    puts block.text if block.type == :text
  end
  ```
</CodeGroup>

## Como o esforço funciona

A maioria dos modelos Claude usa esforço alto por padrão, gastando quantos tokens forem necessários para obter resultados excelentes; Claude Opus 5.5 e Claude Haiku 5.5 usam por padrão o esforço médio. Você pode aumentar o nível de esforço para `max` para obter a capacidade mais alta absoluta, ou reduzi-lo para ser mais conservador no uso de tokens, otimizando velocidade e custo ao aceitar alguma redução na capacidade.

<Tip>
  Definir `effort` como o padrão do modelo (`"medium"` no Claude Opus 5.5 e no Claude Haiku 5.5, `"high"` nos outros modelos) produz exatamente o mesmo comportamento que omitir completamente o parâmetro `effort`.
</Tip>

O parâmetro effort afeta **todos os tokens** na resposta, incluindo:

* Respostas de texto e explicações
* Chamadas de ferramentas e argumentos de funções
* Pensamento (quando ativo)

Como o esforço se aplica a cada token de saída, ele funciona independentemente de o pensamento estar habilitado ou não. Um esforço menor também significa chamadas de ferramentas em menor número e mais concisas.

### Níveis de esforço

| Nível    | Descrição                                                                                                                                                                                                                                                                                                                              | Caso de uso típico                                                                                                    |
| -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `max`    | Capacidade máxima absoluta, sem restrições no gasto de tokens. Disponível no Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5.5, Claude Sonnet 5, Claude Sonnet 4.6 e Claude Haiku 5.5. | Tarefas que exigem o raciocínio mais profundo possível e a análise mais minuciosa                                     |
| `xhigh`  | Capacidade estendida para trabalhos de longo horizonte. Disponível no Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5.5, Claude Sonnet 5 e Claude Haiku 5.5.                                                                   | Tarefas agênticas e de codificação de longa duração (mais de 30 minutos) com orçamentos de tokens na casa dos milhões |
| `high`   | Gasta quantos tokens a tarefa precisar para obter resultados excelentes. O padrão em todos os modelos que suportam esforço, exceto Claude Opus 5.5 e Claude Haiku 5.5.                                                                                                                                                                 | Raciocínio complexo, problemas de codificação difíceis, tarefas agênticas                                             |
| `medium` | Abordagem equilibrada com economia moderada de tokens. O padrão no Claude Opus 5.5 e no Claude Haiku 5.5.                                                                                                                                                                                                                              | Tarefas agênticas que exigem um equilíbrio entre velocidade, custo e desempenho                                       |
| `low`    | O mais eficiente. Economia significativa de tokens com alguma redução de capacidade.                                                                                                                                                                                                                                                   | Tarefas mais simples que precisam da melhor velocidade e dos menores custos, como subagentes                          |

Nem todo modelo que suporta `max` suporta `xhigh`.

<Note>
  O esforço é um sinal comportamental, não um orçamento rígido de tokens. Em níveis de esforço mais baixos, Claude ainda pensa em problemas suficientemente difíceis, mas pensa menos do que pensaria em níveis de esforço mais altos para o mesmo problema.
</Note>

As recomendações por modelo a seguir substituem esta tabela onde houver divergência.

### Níveis de esforço recomendados para o Claude Fable 5.1

O Claude Fable 5.1 suporta todos os cinco níveis de esforço. **Comece com `high`, o padrão.** Suba para `xhigh` ou `max` para os trabalhos agênticos e de codificação mais sensíveis à capacidade, e desça para `medium` ou `low` para trabalhos rotineiros ou sensíveis à latência, uma vez que suas avaliações mostrem que a qualidade se mantém. Em `high` e acima, defina um `max_tokens` grande. É um limite rígido na saída total (pensamento mais texto da resposta). As mesmas recomendações se aplicam ao Claude Mythos 5.1. Consulte [Prompting do Claude Fable 5.1](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels).

O Claude Fable 5.1 também suporta [alterar o esforço no meio da conversa](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#change-effort-mid-conversation-beta) com um `output_config` por mensagem, o que preserva o cache de prompt.

### Níveis de esforço recomendados para o Claude Fable 5

O esforço é o controle principal para equilibrar inteligência, latência e custo no Claude Fable 5. **Comece com `high`, o padrão, para a maioria das tarefas**, use `xhigh` para as cargas de trabalho mais sensíveis à capacidade e desça para `medium` ou `low` para trabalhos rotineiros. Configurações de esforço mais baixas no Claude Fable 5 ainda têm bom desempenho e frequentemente superam o desempenho de `xhigh` em modelos anteriores. Em `high` e `xhigh`, defina um `max_tokens` grande. É um limite rígido na saída total (pensamento mais texto da resposta). Consulte [Controle de custos](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking-steering-and-cost#cost-control).

Reduza o esforço se uma tarefa for concluída, mas demorar mais do que o necessário, ou se você quiser um estilo de trabalho mais rápido e interativo. As mesmas recomendações se aplicam ao Claude Mythos 5. Para orientações mais completas, consulte [Prompting do Claude Fable 5](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/prompting-claude-fable-5).

### Níveis de esforço recomendados para o Claude Opus 5.5

O Claude Opus 5.5 suporta todos os cinco níveis de esforço, e `medium` é o padrão (o Claude Opus 5 e os modelos Opus anteriores usam `high` por padrão, então uma solicitação que omite `effort` é executada um nível abaixo do que era no Claude Opus 5). O pensamento adaptativo está sempre ativo e não pode ser desativado, então o esforço é o principal controle de quanto o modelo raciocina e de quanto uma solicitação custa. Execute uma varredura de esforço nas suas próprias avaliações em vez de reaproveitar configurações de um modelo anterior, e defina um `max_tokens` grande nos níveis mais altos: ele é um limite rígido para a saída total (pensamento mais texto da resposta). Solicitações que definem `thinking: {"type": "disabled"}` retornam um erro 400 em todos os níveis de esforço. O Claude Opus 5.5 também suporta [alterar o esforço no meio da conversa](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#change-effort-mid-conversation-beta) com um `output_config` por mensagem, o que preserva o cache de prompt. Consulte [Prompting do Claude Opus 5.5](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/prompting-claude-opus-5-5).

### Níveis de esforço recomendados para o Claude Opus 5

O Claude Opus 5 suporta todos os cinco níveis de esforço. **Comece com `high`, o padrão**, e ajuste com base em suas avaliações: suba para `xhigh` para trabalhos exigentes de codificação e agênticos, ou para `max` quando uma tarefa justificar gasto irrestrito de tokens, e use `low` e `medium` livremente como seu principal controle de custo de tokens e tempo de resposta sempre que suas avaliações mostrarem que a qualidade se mantém. Se você reaproveitou configurações de esforço de um modelo anterior, execute uma nova varredura de esforço em suas avaliações em vez de reutilizá-las.

O esforço controla o volume de pensamento, não o comprimento visível da resposta: no Claude Opus 5, alterar o esforço não encurta as respostas de forma confiável, então [use o prompt para controlar o comprimento](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/prompting-claude-opus-5#response-length-and-verbosity).

O padrão da API é `high`. Defina `effort` explicitamente para usar um nível diferente. O valor que você passa substitui o padrão.

No Claude Opus 5, o pensamento não pode ser desativado com esforço `xhigh` ou `max`: solicitações que definem `thinking: {"type": "disabled"}` nesses níveis retornam um erro 400. Consulte [Esforço com pensamento](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#effort-with-thinking).

Ao executar o Claude Opus 5 com esforço `xhigh` ou `max`, defina um `max_tokens` grande para que o modelo tenha espaço para pensar e agir em subagentes e chamadas de ferramentas. Começar com 64k tokens e ajustar a partir daí é um padrão razoável.

O Claude Opus 5 também suporta [alterar o esforço no meio da conversa](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#change-effort-mid-conversation-beta) com um `output_config` por mensagem, o que preserva o cache de prompt. O esforço por mensagem não está disponível para o Claude Opus 5 no Amazon Bedrock.

### Níveis de esforço recomendados para o Claude Opus 4.8

As orientações para o Claude Opus 4.7 também se aplicam ao Claude Opus 4.8. **Comece com `xhigh` para casos de uso de codificação e agênticos**, use `high` para a maioria das outras cargas de trabalho sensíveis à inteligência e desça para `medium` ou `low` apenas quando você tiver medido que o nível mais baixo mantém a qualidade em suas avaliações.

O padrão da API é `high`. Defina `effort` explicitamente para usar um nível diferente. O valor que você passa substitui o padrão.

Ao executar o Claude Opus 4.8 com esforço `xhigh` ou `max`, defina um `max_tokens` grande para que o modelo tenha espaço para pensar e agir entre subagentes e chamadas de ferramentas. Começar com 64k tokens e ajustar a partir daí é um padrão razoável.

### Níveis de esforço recomendados para o Claude Opus 4.7

**Comece com `xhigh` para casos de uso de codificação e agênticos**, e use `high` como mínimo para a maioria das cargas de trabalho sensíveis à inteligência. Desça para `medium` para cargas de trabalho sensíveis a custo, ou suba para `max` somente quando suas avaliações mostrarem margem mensurável em `xhigh`.

O padrão da API é `high`. Para usar `xhigh`, defina `effort` explicitamente. O valor que você passa substitui o padrão.

| Esforço  | Orientação para o Claude Opus 4.7                                                                                                                                                                                                                                                 |
| -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `low`    | Eficiente, mas mais adequado para tarefas curtas e bem delimitadas. Combine `low` com checklists explícitos se sua tarefa tiver várias seções.                                                                                                                                    |
| `medium` | A opção direta para o fluxo de trabalho médio em que você quer bons resultados enquanto reduz custos.                                                                                                                                                                             |
| `high`   | Casos de uso avançados que ainda precisam de um equilíbrio entre inteligência e consumo de tokens. Este costuma ser o melhor equilíbrio entre qualidade e eficiência de tokens.                                                                                                   |
| `xhigh`  | O ponto de partida recomendado para trabalhos de codificação e agênticos, e para tarefas exploratórias, como chamadas repetidas de ferramentas, pesquisa detalhada na web e pesquisa em bases de conhecimento. Espere um uso de tokens significativamente maior do que em `high`. |
| `max`    | Reserve para problemas de fronteira. Na maioria das cargas de trabalho, `max` adiciona custo significativo para ganhos de qualidade relativamente pequenos e, em algumas tarefas de saída estruturada ou menos sensíveis à inteligência, pode levar a pensamento excessivo.       |

O Claude Opus 4.7 também respeita os níveis de esforço de forma mais rigorosa do que o Claude Opus 4.6, especialmente em `low` e `medium`. Em níveis de esforço mais baixos, o modelo limita seu trabalho ao que foi pedido, em vez de fazer mais do que o solicitado. Se você observar raciocínio superficial em problemas complexos com o Claude Opus 4.7, aumente o esforço em vez de tentar contornar isso com o prompt. Se precisar manter o esforço baixo por causa da latência, adicione orientações direcionadas como "Esta tarefa envolve raciocínio em várias etapas. Pense cuidadosamente antes de responder."

Ao executar o Claude Opus 4.7 com esforço `xhigh` ou `max`, defina um `max_tokens` grande para que o modelo tenha espaço para pensar e agir em subagentes e chamadas de ferramentas. Começar com 64k tokens e ajustar a partir daí é um padrão razoável.

### Níveis de esforço recomendados para o Claude Sonnet 5.5

O Claude Sonnet 5.5 suporta todos os cinco níveis de esforço, e `high` é o padrão na Claude API. Seus níveis foram recalibrados, então um nível não produz a mesma quantidade de pensamento que o mesmo nível no Claude Sonnet 5. Execute uma nova varredura de esforço em suas avaliações em vez de reaproveitar a configuração que você usava no Claude Sonnet 5. Comece com `high`, a menos que sua carga de trabalho seja agêntica ou sensível à latência. Para codificação agêntica e uso de ferramentas em várias etapas, comece com `medium` para tarefas bem especificadas e passe para `high` para tarefas mais difíceis ou mais longas. Para chat e outros trabalhos sensíveis à latência, comece com `medium` ou `low`. Use `xhigh` ou `max` somente onde suas avaliações mostrarem ganho de qualidade. Defina `max_tokens` com espaço para o pensamento e a resposta. O pensamento conta para `max_tokens` mesmo quando o conteúdo do pensamento não é retornado. Para codificação agêntica, defina `max_tokens` como 128.000, o máximo do modelo, e faça [streaming](https://platform.claude.com/docs/pt-BR/build-with-claude/streaming) da resposta.

Para desativar o pensamento antecipado, envie `thinking: {"type": "between_tools"}` em vez de `"disabled"`. Essa é a configuração de pensamento mais baixa no Claude Sonnet 5.5, e funciona com esforço `low`, `medium` e `high`. Em `xhigh` ou `max`, uma solicitação com ela retorna um erro 400, então use o pensamento adaptativo nesses níveis: omita o campo `thinking` ou envie `thinking: {"type": "adaptive"}`. Consulte [Executar sem pensamento antecipado](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).

O Claude Sonnet 5.5 também suporta [alterar o esforço no meio da conversa](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#change-effort-mid-conversation-beta) com um `output_config` por mensagem, o que preserva o cache de prompt. Com `between_tools`, o esforço não pode mudar no meio da conversa: um `output_config.effort` por mensagem que difere do nível em vigor retorna um erro 400. Para variar o esforço a cada turno, use o pensamento adaptativo. Consulte [Como escrever prompts para o Claude Sonnet 5.5](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#calibrate-effort).

### Níveis de esforço recomendados para o Claude Sonnet 5

O Claude Sonnet 5 usa esforço `high` por padrão na API do Claude e no Claude Code.

* **Esforço high (padrão):** Adequado para raciocínio complexo, codificação e tarefas agênticas em que a qualidade importa mais do que velocidade ou custo.
* **Esforço xhigh:** Para as tarefas de codificação e agênticas mais difíceis. Consulte [Prompting do Claude Sonnet 5](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/prompting-claude-sonnet-5#calibrating-effort-and-thinking-depth).
* **Esforço medium:** Redução de custo em relação ao padrão. Comparável ao Claude Sonnet 4.6 com esforço high.
* **Esforço low:** Para cargas de trabalho de alto volume ou sensíveis à latência. Adequado para chat e casos de uso que não envolvem codificação, em que um retorno mais rápido é priorizado.
* **Esforço max:** Para tarefas que exigem a capacidade absolutamente mais alta sem restrições no gasto de tokens.

### Níveis de esforço recomendados para o Claude Sonnet 4.6

O Sonnet 4.6 usa esforço `high` por padrão. Defina o esforço explicitamente ao usar o Sonnet 4.6 para evitar latência inesperada:

* **Esforço medium** (padrão recomendado): Melhor equilíbrio entre velocidade, custo e desempenho para a maioria das aplicações. Adequado para codificação agêntica, fluxos de trabalho com uso intenso de ferramentas e geração de código.
* **Esforço low:** Para cargas de trabalho de alto volume ou sensíveis à latência. Adequado para chat e casos de uso que não envolvem codificação, em que um retorno mais rápido é priorizado.
* **Esforço high:** Para raciocínio complexo e tarefas em que a qualidade importa mais do que velocidade ou custo.
* **Esforço max:** Para tarefas que exigem a capacidade mais alta absoluta, sem restrições no gasto de tokens.

### Níveis de esforço recomendados para o Claude Haiku 5.5

O Claude Haiku 5.5 suporta todos os cinco níveis de esforço, e `medium` é o padrão. O esforço é o principal controle de quanto o modelo pensa e, com isso, da qualidade, latência e custo. **Comece com `medium`** para a maioria dos trabalhos, incluindo codificação agêntica. Use `low`, o nível mais barato e mais rápido, para chat, tarefas curtas com ferramentas e solicitações simples de alto volume. Em prompts longos de agentes, o modelo tem mais probabilidade de pular uma pesquisa, parar cedo ou pular uma verificação em `low`. Use `high` para trabalho de conhecimento, tarefas de agente mais longas e seguimento rigoroso de instruções. Use `xhigh` ou `max` somente onde suas avaliações mostrarem ganho de qualidade, e compare-os com o Claude Sonnet 5.5 em desempenho, custo e velocidade. O pensamento está ativado por padrão e conta para `max_tokens`, então deixe espaço para ele. Consulte [Prompting do Claude Haiku 5.5](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking).

Para obter menos pensamento, reduza o nível de esforço. Você também pode enviar `thinking: {"type": "disabled"}` com esforço `high` ou inferior. Em `xhigh` ou `max`, isso retorna um erro 400, então use o pensamento adaptativo nesses níveis: omita o campo `thinking` ou envie `thinking: {"type": "adaptive"}`.

Na Claude API e no Google Cloud, o Claude Haiku 5.5 também suporta [alterar o esforço no meio da conversa](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#change-effort-mid-conversation-beta) com um `output_config` por mensagem, o que preserva o cache de prompt. Com `thinking: {"type": "disabled"}`, o esforço não pode mudar no meio da conversa: um `output_config.effort` por mensagem que difere do nível em vigor retorna um erro 400. Para variar o esforço a cada turno, use o pensamento adaptativo.

## Esforço com uso de ferramentas

Ao usar ferramentas, o parâmetro effort afeta tanto as explicações em torno das chamadas de ferramentas quanto as próprias chamadas de ferramentas. Níveis de esforço mais baixos tendem a:

* Combinar várias operações em menos chamadas de ferramentas
* Fazer menos chamadas de ferramentas
* Prosseguir diretamente para a ação sem preâmbulo
* Usar mensagens de confirmação concisas após a conclusão

Níveis de esforço mais altos podem:

* Fazer mais chamadas de ferramentas
* Explicar o plano antes de agir
* Fornecer resumos detalhados das alterações
* Incluir comentários de código mais abrangentes

## Esforço com pensamento

O parâmetro `thinking` controla se o Claude pensa em [blocos de pensamento](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking) antes de responder; o parâmetro `effort` controla quanto trabalho o Claude dedica à resposta inteira, o que, no modo adaptativo, inclui com que frequência e com que profundidade ele pensa. Não passe `adaptive` como um valor de `effort`: `adaptive` é um modo de pensamento, não um nível de esforço.

Em níveis de esforço mais altos, Claude pensa com mais facilidade e por mais tempo. Em um loop de uso de ferramentas, solicitações de acompanhamento que apenas processam resultados de ferramentas ainda podem pular o pensamento em qualquer nível. Em níveis mais baixos, Claude pode pular o pensamento completamente em problemas mais simples. Consulte [Pensamento e esforço](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking#thinking-and-effort) para orientações completas sobre como os dois controles funcionam juntos.

No Claude Opus 4.5, o único modelo exclusivamente de "extended thinking" (pensamento estendido) que suporta esforço, ele funciona em conjunto com [`budget_tokens`](https://platform.claude.com/docs/pt-BR/build-with-claude/extended-thinking): defina o nível de esforço para sua tarefa e, em seguida, defina o orçamento de tokens de pensamento com base em quanta profundidade de raciocínio a tarefa precisa.

Para a disponibilidade de pensamento por modelo, consulte a [tabela de configuração por modelo](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking-troubleshooting#supported-models). O esforço funciona com ou sem pensamento. Consulte [Como o esforço funciona](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#how-effort-works).

## Alterar o esforço no meio da conversa

Você pode executar turnos posteriores de uma conversa em um nível de esforço diferente de duas maneiras. No Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 e Claude Haiku 5.5, use uma alteração de esforço por mensagem, que mantém o cache de prompt. Em outros modelos, defina um novo valor de nível superior na próxima solicitação, o que reinicia o cache.

### Esforço por mensagem (beta)

O esforço por mensagem está em beta. Na Claude API e no [Google Cloud](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-vertex-ai), ele está disponível no Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 e Claude Haiku 5.5. No [Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock), ele está disponível no Claude Fable 5.1, Claude Mythos 5.1 e Claude Opus 5.5. Ele requer o [cabeçalho beta](https://platform.claude.com/docs/pt-BR/api/beta-headers) `mid-conversation-output-config-2026-07-01`. Com a [InvokeModel API](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-amazon-bedrock-legacy) do Amazon Bedrock, ele está disponível no Claude Fable 5.1 e no Claude Opus 5.5, e você envia esse valor no array `anthropic_beta` do corpo da solicitação.

Sem o valor beta, um `output_config` por mensagem retorna um erro 400: `messages.N.output_config: Extra inputs are not permitted`, em que `N` é o índice da mensagem `system` em `messages`. Com o valor beta, modelos sem esforço por mensagem, incluindo o Claude Fable 5, retornam um erro 400: `output_config.effort requires a model that supports per-turn effort; this model does not`. No Amazon Bedrock, esses modelos e o Claude Opus 5 retornam o erro `Extra inputs are not permitted`. No Claude Sonnet 5.5 com `thinking: {"type": "between_tools"}` e no Claude Haiku 5.5 com `thinking: {"type": "disabled"}`, o esforço não pode mudar no meio da conversa: um `output_config.effort` por mensagem que difere do nível em vigor retorna um erro 400. Para variar o esforço a cada turno, use o pensamento adaptativo.

Adicione uma mensagem `role: "system"` com `content` vazio e o novo nível em `output_config.effort`. Colocada diretamente após um turno `user` com nova entrada, ela define o nível da resposta de Claude a esse turno. Colocada em qualquer outro lugar, como entre um turno `assistant` e o próximo turno `user`, como no exemplo a seguir, ela entra em vigor a partir do próximo turno `user` com nova entrada. Um turno `user` que contém apenas blocos `tool_result` não conta como nova entrada, então uma alteração colocada após um deles em um loop de uso de ferramentas aguarda o próximo turno `user` com nova entrada. O novo nível então se mantém até que uma mensagem posterior o altere. Tudo antes dessa mensagem permanece inalterado, então o prefixo em cache ainda corresponde.

O exemplo a seguir começa em `high` e depois cai para `low` em um acompanhamento rotineiro:

<CodeGroup>
  ```bash cURL
  # Mensagem do sistema só de esforço: o novo nível vale a partir do próximo turno do usuário.
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: mid-conversation-output-config-2026-07-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-fable-5-1",
      "max_tokens": 4096,
      "output_config": {"effort": "high"},
      "messages": [
        {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
        {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."}
      ]
    }'
  ```

  ```bash CLI
  ant beta:messages create --beta mid-conversation-output-config-2026-07-01 \
    --transform 'content.#(type=="text").text' --raw-output <<'YAML'
  model: claude-fable-5-1
  max_tokens: 4096
  output_config:
    effort: high
  messages:
    - role: user
      content: Plan a migration from SQLite to PostgreSQL in three short steps.
    - role: assistant
      content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
    # Mensagem do sistema só de esforço: o novo nível vale a partir do próximo turno do usuário.
    - role: system
      content: []
      output_config:
        effort: low
    - role: user
      content: Summarize the plan in one sentence.
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.beta.messages.create(
      model="claude-fable-5-1",
      max_tokens=4096,
      output_config={"effort": "high"},
      messages=[
          {
              "role": "user",
              "content": "Plan a migration from SQLite to PostgreSQL in three short steps.",
          },
          {
              "role": "assistant",
              "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.",
          },
          # Mensagem de sistema só de esforço: o novo nível vale a partir do próximo turno do usuário.
          {"role": "system", "content": [], "output_config": {"effort": "low"}},
          {"role": "user", "content": "Summarize the plan in one sentence."},
      ],
      betas=["mid-conversation-output-config-2026-07-01"],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.beta.messages.create({
    model: "claude-fable-5-1",
    max_tokens: 4096,
    output_config: { effort: "high" },
    messages: [
      {
        role: "user",
        content: "Plan a migration from SQLite to PostgreSQL in three short steps."
      },
      {
        role: "assistant",
        content:
          "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
      },
      // Mensagem de sistema só de esforço: o novo nível vale a partir do próximo turno do usuário.
      { role: "system", content: [], output_config: { effort: "low" } },
      { role: "user", content: "Summarize the plan in one sentence." }
    ],
    betas: ["mid-conversation-output-config-2026-07-01"]
  });

  for (const block of response.content) {
    if (block.type === "text") {
      console.log(block.text);
    }
  }
  ```

  ```csharp C#
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Model = Anthropic.Models.Messages.Model;

  AnthropicClient client = new();

  var response = await client.Beta.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeFable5_1,
      MaxTokens = 4096,
      OutputConfig = new() { Effort = Effort.High },
      Messages =
      [
          new() { Role = Role.User, Content = "Plan a migration from SQLite to PostgreSQL in three short steps." },
          new() { Role = Role.Assistant, Content = "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts." },
          // Mensagem de sistema só de esforço: o novo nível vale a partir do próximo turno do usuário.
          new()
          {
              Role = Role.System,
              Content = new([]),
              OutputConfig = new() { Effort = BetaSystemMessageOutputConfigEffort.Low },
          },
          new() { Role = Role.User, Content = "Summarize the plan in one sentence." },
      ],
      Betas = [AnthropicBeta.MidConversationOutputConfig2026_07_01],
  });

  foreach (var block in response.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeFable5_1,
  	MaxTokens: 4096,
  	OutputConfig: anthropic.BetaOutputConfigParam{
  		Effort: anthropic.BetaOutputConfigEffortHigh,
  	},
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Plan a migration from SQLite to PostgreSQL in three short steps.")),
  		{
  			Role:    anthropic.BetaMessageParamRoleAssistant,
  			Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")},
  		},
  		// Mensagem de sistema só de esforço: o novo nível vale a partir do próximo turno do usuário.
  		anthropic.NewBetaSystemMessage(anthropic.BetaSystemMessageOutputConfigParam{
  			Effort: anthropic.BetaSystemMessageOutputConfigEffortLow,
  		}),
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize the plan in one sentence.")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMidConversationOutputConfig2026_07_01},
  })
  if err != nil {
  	log.Fatal(err)
  }

  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.beta.AnthropicBeta;
  import com.anthropic.models.beta.messages.BetaMessage;
  import com.anthropic.models.beta.messages.BetaMessageParam;
  import com.anthropic.models.beta.messages.BetaOutputConfig;
  import com.anthropic.models.beta.messages.BetaSystemMessageOutputConfig;
  import com.anthropic.models.beta.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_FABLE_5_1)
          .maxTokens(4096L)
          .addBeta(AnthropicBeta.MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01)
          .outputConfig(BetaOutputConfig.builder()
              .effort(BetaOutputConfig.Effort.HIGH)
              .build())
          .addUserMessage("Plan a migration from SQLite to PostgreSQL in three short steps.")
          .addAssistantMessage("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")
          // Mensagem de sistema só de esforço: o novo nível vale a partir do próximo turno do usuário.
          .addMessage(BetaMessageParam.builder()
              .role(BetaMessageParam.Role.SYSTEM)
              .contentOfBetaContentBlockParams(List.of())
              .outputConfig(BetaSystemMessageOutputConfig.builder()
                  .effort(BetaSystemMessageOutputConfig.Effort.LOW)
                  .build())
              .build())
          .addUserMessage("Summarize the plan in one sentence.")
          .build();

      BetaMessage response = client.beta().messages().create(params);
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  use Anthropic\Beta\AnthropicBeta;
  use Anthropic\Beta\Messages\BetaMessageParam;
  use Anthropic\Beta\Messages\BetaOutputConfig;
  use Anthropic\Beta\Messages\BetaSystemMessageOutputConfig;
  use Anthropic\Client;

  $client = new Client();

  $response = $client->beta->messages->create(
      model: 'claude-fable-5-1',
      maxTokens: 4096,
      outputConfig: BetaOutputConfig::with(effort: 'high'),
      messages: [
          BetaMessageParam::with(role: 'user', content: 'Plan a migration from SQLite to PostgreSQL in three short steps.'),
          BetaMessageParam::with(role: 'assistant', content: '1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.'),
          // Mensagem do sistema só de esforço: o novo nível vale a partir do próximo turno do usuário.
          BetaMessageParam::with(
              role: 'system',
              content: [],
              outputConfig: BetaSystemMessageOutputConfig::with(effort: 'low'),
          ),
          BetaMessageParam::with(role: 'user', content: 'Summarize the plan in one sentence.'),
      ],
      betas: [AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01],
  );

  foreach ($response->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-fable-5-1",
    max_tokens: 4096,
    output_config: {effort: :high},
    messages: [
      {role: "user", content: "Plan a migration from SQLite to PostgreSQL in three short steps."},
      {role: "assistant", content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
      # Mensagem do sistema só de esforço: o novo nível vale a partir do próximo turno do usuário.
      {role: "system", content: [], output_config: {effort: :low}},
      {role: "user", content: "Summarize the plan in one sentence."}
    ],
    betas: [Anthropic::AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01]
  )

  response.content.each do |block|
    puts block.text if block.type == :text
  end
  ```
</CodeGroup>

Uma mensagem de sistema apenas de esforço não contém texto, então as [regras de posicionamento para mensagens de sistema no meio da conversa](https://platform.claude.com/docs/pt-BR/build-with-claude/mid-conversation-system-messages#limitations) não se aplicam. Ela pode aparecer em qualquer lugar em `messages`, inclusive como a primeira entrada ou entre um turno `assistant` e o próximo turno `user`. Os valores são os nomes dos níveis (`low`, `medium`, `high`, `xhigh` e `max`).

Prefira esta forma a alterar o valor de nível superior entre solicitações. Uma alteração de nível superior reinicia o cache e, no Claude Fable 5.1, também direciona o modelo de forma menos confiável: suas respostas anteriores foram escritas no nível anterior, e ele tende a permanecer consistente com elas.

### Esforço de nível superior na próxima solicitação

O `output_config.effort` de nível superior se aplica à solicitação inteira. Para executar uma parte posterior de uma conversa em um nível diferente, defina o novo valor na próxima solicitação. Como o esforço de nível superior molda o prompt renderizado, alterá-lo entre solicitações não preserva os prefixos em cache de turnos anteriores. Se você depende de [cache de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching) ao longo de uma sessão longa e seu modelo não suporta esforço por mensagem, escolha um nível de esforço no início e mantenha-o constante.

## Melhores práticas

1. **Defina o esforço explicitamente:** A API usa `high` por padrão (`medium` no Claude Opus 5.5 e no Claude Haiku 5.5), mas o ponto de partida certo depende do seu modelo e da sua carga de trabalho.
2. **Use low para tarefas sensíveis à velocidade ou simples:** Quando a latência importa ou as tarefas são diretas, o esforço baixo pode reduzir significativamente os tempos de resposta e os custos.
3. **Teste seu caso de uso:** O impacto dos níveis de esforço varia conforme o tipo de tarefa. Avalie o desempenho em seus casos de uso específicos antes de implantar.
4. **Considere o esforço dinâmico:** Ajuste o esforço com base na complexidade da tarefa. Consultas simples podem justificar esforço baixo, enquanto codificação agêntica e raciocínio complexo se beneficiam de esforço alto. Veja o próximo item antes de variá-lo dentro de uma mesma conversa.
5. **Mantenha o esforço de nível superior constante em conversas com cache:** Alterar o valor de esforço de nível superior entre solicitações invalida o [cache de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching), então varie-o entre cargas de trabalho, e não dentro de uma conversa que depende de acertos de cache. Em modelos que oferecem suporte, use uma [alteração de esforço por mensagem](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#change-effort-mid-conversation-beta), que preserva o cache. Consulte [Pensamento e cache de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking#thinking-and-prompt-caching).

## Próximos passos

<CardGroup>
  <Card title="Orçamentos de tarefa" icon="gauge" href="https://platform.claude.com/docs/pt-BR/build-with-claude/task-budgets">
    Dê a Claude um orçamento consultivo de tokens para todo o loop agêntico, ajudando o modelo a se autorregular em tarefas agênticas longas.
  </Card>

  <Card title="Direcionando o pensamento" icon="compass" href="https://platform.claude.com/docs/pt-BR/build-with-claude/thinking-steering-and-cost">
    Entenda o pensamento adaptativo, em que Claude determina quando e quanto pensar, e direcione-o com esforço e prompts.
  </Card>

  <Card title="Pensamento" icon="brain" href="https://platform.claude.com/docs/pt-BR/build-with-claude/thinking">
    Entenda como o pensamento funciona, quando Claude pensa por padrão e como o pensamento interage com o esforço.
  </Card>
</CardGroup>