---
title: Esfuerzo
url: https://platform.claude.com/docs/es/build-with-claude/effort
description: Controla cuántos tokens usa Claude al responder con el parámetro effort, equilibrando la exhaustividad de la respuesta y la eficiencia 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
---

El parámetro "effort" (esfuerzo) te permite controlar cuántos tokens gasta Claude al responder a las solicitudes. Puedes equilibrar entre la exhaustividad de la respuesta y la eficiencia de tokens con un solo modelo. El parámetro effort de nivel superior está disponible en todos los modelos compatibles sin necesidad de un encabezado beta. El [esfuerzo por mensaje](https://platform.claude.com/docs/es/build-with-claude/effort#change-effort-mid-conversation-beta) está en beta.

<Tip>
  Para aprender cómo interactúa el esfuerzo con el pensamiento y qué control utilizar, consulta [Pensamiento y esfuerzo](https://platform.claude.com/docs/es/build-with-claude/thinking#thinking-and-effort). Donde el pensamiento adaptativo está disponible, el esfuerzo es la forma recomendada de controlar la profundidad del pensamiento.
</Tip>

## Establece el nivel de esfuerzo

Establece `output_config.effort` en la solicitud. El siguiente ejemplo ejecuta una solicitud con esfuerzo `medium` e imprime el texto de la respuesta.

<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>

## Cómo funciona el esfuerzo

La mayoría de los modelos de Claude usan esfuerzo alto de forma predeterminada, gastando tantos tokens como sea necesario para obtener resultados excelentes; Claude Opus 5.5 y Claude Haiku 5.5 usan medio de forma predeterminada. Puedes subir el nivel de esfuerzo a `max` para obtener la máxima capacidad absoluta, o bajarlo para ser más conservador con el uso de tokens, optimizando la velocidad y el costo a cambio de cierta reducción en la capacidad.

<Tip>
  Establecer `effort` en el valor predeterminado del modelo (`"medium"` en Claude Opus 5.5 y Claude Haiku 5.5, `"high"` en otros modelos) produce exactamente el mismo comportamiento que omitir por completo el parámetro `effort`.
</Tip>

El parámetro effort afecta a **todos los tokens** de la respuesta, incluidos:

* Respuestas de texto y explicaciones
* "Tool calls" (llamadas a herramientas) y argumentos de funciones
* Pensamiento (cuando está activo)

Como el esfuerzo se aplica a cada token de salida, funciona tanto si el pensamiento está habilitado como si no. Un esfuerzo menor también implica menos llamadas a herramientas y más concisas.

### Niveles de esfuerzo

| Nivel    | Descripción                                                                                                                                                                                                                                                                                                                                | Caso de uso típico                                                                                              |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
| `max`    | Capacidad máxima absoluta sin restricciones en el gasto de tokens. Disponible en 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 y Claude Haiku 5.5. | Tareas que requieren el razonamiento más profundo posible y el análisis más exhaustivo                          |
| `xhigh`  | Capacidad ampliada para trabajo de largo horizonte. Disponible en 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 y Claude Haiku 5.5.                                                                           | Tareas agénticas y de programación de larga duración (más de 30 minutos) con presupuestos de tokens de millones |
| `high`   | Gasta tantos tokens como la tarea necesite para obtener resultados excelentes. Es el valor predeterminado en todos los modelos que admiten esfuerzo, excepto Claude Opus 5.5 y Claude Haiku 5.5.                                                                                                                                           | Razonamiento complejo, problemas de programación difíciles, tareas agénticas                                    |
| `medium` | Enfoque equilibrado con un ahorro moderado de tokens. Es el valor predeterminado en Claude Opus 5.5 y Claude Haiku 5.5.                                                                                                                                                                                                                    | Tareas agénticas que requieren un equilibrio entre velocidad, costo y rendimiento                               |
| `low`    | El más eficiente. Ahorro significativo de tokens con cierta reducción de capacidad.                                                                                                                                                                                                                                                        | Tareas más sencillas que necesitan la mejor velocidad y los costos más bajos, como los subagentes               |

No todos los modelos que admiten `max` admiten `xhigh`.

<Note>
  El esfuerzo es una señal de comportamiento, no un presupuesto estricto de tokens. En niveles de esfuerzo más bajos, Claude sigue pensando en problemas suficientemente difíciles, pero piensa menos de lo que lo haría en niveles de esfuerzo más altos para el mismo problema.
</Note>

Las recomendaciones por modelo que siguen prevalecen sobre esta tabla cuando difieren.

### Niveles de esfuerzo recomendados para Claude Fable 5.1

Claude Fable 5.1 admite los cinco niveles de esfuerzo. **Comienza con `high`, el valor predeterminado.** Sube a `xhigh` o `max` para el trabajo agéntico y de programación más sensible a la capacidad, y baja a `medium` o `low` para trabajo rutinario o sensible a la latencia una vez que tus evaluaciones muestren que la calidad se mantiene. En `high` y superiores, establece un `max_tokens` grande. Es un límite estricto sobre la salida total (pensamiento más texto de respuesta). Las mismas recomendaciones se aplican a Claude Mythos 5.1. Consulta [Prompting para Claude Fable 5.1](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels).

Claude Fable 5.1 también admite [cambiar el esfuerzo a mitad de conversación](https://platform.claude.com/docs/es/build-with-claude/effort#change-effort-mid-conversation-beta) con un `output_config` por mensaje, lo que preserva la caché de prompts.

### Niveles de esfuerzo recomendados para Claude Fable 5

El esfuerzo es el control principal para equilibrar inteligencia, latencia y costo en Claude Fable 5. **Comienza con `high`, el valor predeterminado, para la mayoría de las tareas**, usa `xhigh` para las cargas de trabajo más sensibles a la capacidad, y baja a `medium` o `low` para trabajo rutinario. Las configuraciones de esfuerzo más bajas en Claude Fable 5 siguen funcionando bien y a menudo superan el rendimiento de `xhigh` en modelos anteriores. En `high` y `xhigh`, establece un `max_tokens` grande. Es un límite estricto sobre la salida total (pensamiento más texto de respuesta). Consulta [Control de costos](https://platform.claude.com/docs/es/build-with-claude/thinking-steering-and-cost#cost-control).

Reduce el esfuerzo si una tarea se completa pero tarda más de lo necesario, o si quieres un estilo de trabajo más rápido e interactivo. Las mismas recomendaciones se aplican a Claude Mythos 5. Para una guía más completa, consulta [Prompting para Claude Fable 5](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-fable-5).

### Niveles de esfuerzo recomendados para Claude Opus 5.5

Claude Opus 5.5 admite los cinco niveles de esfuerzo, y `medium` es el valor predeterminado (Claude Opus 5 y los modelos Opus anteriores usan `high` de forma predeterminada, por lo que una solicitud que omite `effort` se ejecuta un nivel más bajo que en Claude Opus 5). El pensamiento adaptativo siempre está activado y no se puede desactivar, por lo que el esfuerzo es el control principal de cuánto razona el modelo y cuánto cuesta una solicitud. Ejecuta un barrido de esfuerzo en tus propias evaluaciones en lugar de trasladar los ajustes de un modelo anterior, y establece un `max_tokens` grande en los niveles más altos: es un límite estricto sobre la salida total (pensamiento más texto de respuesta). Las solicitudes que establecen `thinking: {"type": "disabled"}` devuelven un error 400 en todos los niveles de esfuerzo. Claude Opus 5.5 también admite [cambiar el esfuerzo a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/effort#change-effort-mid-conversation-beta) con un `output_config` por mensaje, lo que preserva la caché de prompts. Consulta [Cómo escribir prompts para Claude Opus 5.5](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-opus-5-5).

### Niveles de esfuerzo recomendados para Claude Opus 5

Claude Opus 5 admite los cinco niveles de esfuerzo. **Empieza con `high`, el valor predeterminado**, y ajusta según tus evaluaciones: sube a `xhigh` para trabajo exigente de programación y agéntico, o a `max` cuando una tarea justifique un gasto de tokens sin restricciones, y usa `low` y `medium` con libertad como tu control principal del costo de tokens y del tiempo de respuesta siempre que tus evaluaciones muestren que la calidad se mantiene. Si trasladaste ajustes de esfuerzo de un modelo anterior, ejecuta un nuevo barrido de esfuerzo en tus evaluaciones en lugar de reutilizarlos.

El esfuerzo controla el volumen de pensamiento, no la longitud visible de la respuesta: en Claude Opus 5, cambiar el esfuerzo no acorta las respuestas de forma fiable, así que [indica la longitud en el prompt](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-opus-5#response-length-and-verbosity) en su lugar.

El valor predeterminado de la API es `high`. Establece `effort` explícitamente para usar un nivel diferente. El valor que pases prevalece sobre el predeterminado.

En Claude Opus 5, el pensamiento no se puede desactivar con esfuerzo `xhigh` o `max`: las solicitudes que establecen `thinking: {"type": "disabled"}` en esos niveles devuelven un error 400. Consulta [Esfuerzo con pensamiento](https://platform.claude.com/docs/es/build-with-claude/effort#effort-with-thinking).

Al ejecutar Claude Opus 5 con esfuerzo `xhigh` o `max`, establece un `max_tokens` grande para que el modelo tenga espacio para pensar y actuar a través de subagentes y llamadas a herramientas. Empezar con 64k tokens y ajustar a partir de ahí es un valor predeterminado razonable.

Claude Opus 5 también admite [cambiar el esfuerzo a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/effort#change-effort-mid-conversation-beta) con un `output_config` por mensaje, lo que conserva la caché de prompts. El esfuerzo por mensaje no está disponible para Claude Opus 5 en Amazon Bedrock.

### Niveles de esfuerzo recomendados para Claude Opus 4.8

La guía para Claude Opus 4.7 también se aplica a Claude Opus 4.8. **Comienza con `xhigh` para casos de uso de programación y agénticos**, usa `high` para la mayoría de las demás cargas de trabajo sensibles a la inteligencia, y baja a `medium` o `low` solo cuando hayas medido que el nivel inferior mantiene la calidad en tus evaluaciones.

El valor predeterminado de la API es `high`. Establece `effort` explícitamente para usar un nivel diferente. El valor que pases prevalece sobre el predeterminado.

Al ejecutar Claude Opus 4.8 con esfuerzo `xhigh` o `max`, establece un `max_tokens` grande para que el modelo tenga espacio para pensar y actuar a través de subagentes y llamadas a herramientas. Comenzar con 64k tokens y ajustar a partir de ahí es un valor predeterminado razonable.

### Niveles de esfuerzo recomendados para Claude Opus 4.7

**Empieza con `xhigh` para casos de uso de programación y agénticos**, y usa `high` como mínimo para la mayoría de las cargas de trabajo sensibles a la inteligencia. Baja a `medium` para cargas de trabajo sensibles al costo, o sube a `max` solo cuando tus evaluaciones muestren un margen de mejora medible en `xhigh`.

El valor predeterminado de la API es `high`. Para usar `xhigh`, establece `effort` explícitamente. El valor que pases prevalece sobre el predeterminado.

| Esfuerzo | Guía para Claude Opus 4.7                                                                                                                                                                                                                                                                             |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `low`    | Eficiente, pero más adecuado para tareas cortas y acotadas. Combina `low` con listas de verificación explícitas si tu tarea tiene varias secciones.                                                                                                                                                   |
| `medium` | La opción directa para el flujo de trabajo promedio en el que quieres buenos resultados mientras reduces costos.                                                                                                                                                                                      |
| `high`   | Casos de uso avanzados que aún necesitan un equilibrio entre inteligencia y consumo de tokens. A menudo es el mejor equilibrio entre calidad y eficiencia de tokens.                                                                                                                                  |
| `xhigh`  | El punto de partida recomendado para trabajo de programación y agéntico, y para tareas exploratorias como llamadas repetidas a herramientas, búsqueda web detallada y búsqueda en bases de conocimiento. Espera un uso de tokens considerablemente mayor que con `high`.                              |
| `max`    | Resérvalo para problemas de frontera. En la mayoría de las cargas de trabajo, `max` añade un costo significativo a cambio de mejoras de calidad relativamente pequeñas, y en algunas tareas de salida estructurada o menos sensibles a la inteligencia puede provocar que el modelo piense en exceso. |

Claude Opus 4.7 también respeta los niveles de esfuerzo de forma más estricta que Claude Opus 4.6, especialmente en `low` y `medium`. En niveles de esfuerzo más bajos, el modelo limita su trabajo a lo que se pidió en lugar de hacer más de lo solicitado. Si observas un razonamiento superficial en problemas complejos con Claude Opus 4.7, sube el esfuerzo en lugar de intentar compensarlo con el prompt. Si debes mantener el esfuerzo bajo por la latencia, añade una guía específica como "Esta tarea implica razonamiento de varios pasos. Piensa cuidadosamente antes de responder."

Al ejecutar Claude Opus 4.7 con esfuerzo `xhigh` o `max`, establece un `max_tokens` grande para que el modelo tenga espacio para pensar y actuar a través de subagentes y llamadas a herramientas. Empezar con 64k tokens y ajustar a partir de ahí es un valor predeterminado razonable.

### Niveles de esfuerzo recomendados para Claude Sonnet 5.5

Claude Sonnet 5.5 admite los cinco niveles de esfuerzo, y `high` es el valor predeterminado en la Claude API. Sus niveles están recalibrados, por lo que un nivel no produce la misma cantidad de pensamiento que el mismo nivel en Claude Sonnet 5. Ejecuta un nuevo barrido de esfuerzo en tus evaluaciones en lugar de trasladar el ajuste que usabas en Claude Sonnet 5. Empieza con `high` a menos que tu carga de trabajo sea agéntica o sensible a la latencia. Para programación agéntica y uso de herramientas de varios pasos, empieza con `medium` para tareas bien especificadas y pasa a `high` para las más difíciles o largas. Para chat y otro trabajo sensible a la latencia, empieza con `medium` o `low`. Usa `xhigh` o `max` solo donde tus evaluaciones muestren una mejora de calidad. Establece `max_tokens` con espacio para el pensamiento y la respuesta. El pensamiento cuenta para `max_tokens` incluso cuando el contenido del pensamiento no se devuelve. Para programación agéntica, establece `max_tokens` en 128,000, el máximo del modelo, y usa [streaming](https://platform.claude.com/docs/es/build-with-claude/streaming) para la respuesta.

Para desactivar el pensamiento previo, envía `thinking: {"type": "between_tools"}` en lugar de `"disabled"`. Es el ajuste de pensamiento más bajo en Claude Sonnet 5.5 y funciona con esfuerzo `low`, `medium` y `high`. En `xhigh` o `max`, una solicitud con este ajuste devuelve un error 400, así que usa pensamiento adaptativo en esos niveles: omite el campo `thinking` o envía `thinking: {"type": "adaptive"}`. Consulta [Ejecutar sin pensamiento previo](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).

Claude Sonnet 5.5 también admite [cambiar el esfuerzo a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/effort#change-effort-mid-conversation-beta) con un `output_config` por mensaje, lo que conserva la caché de prompts. Con `between_tools`, el esfuerzo no puede cambiar a mitad de la conversación: un `output_config.effort` por mensaje que difiera del nivel vigente devuelve un error 400. Para variar el esfuerzo por turno, usa pensamiento adaptativo. Consulta [Cómo escribir prompts para Claude Sonnet 5.5](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#calibrate-effort).

### Niveles de esfuerzo recomendados para Claude Sonnet 5

Claude Sonnet 5 usa esfuerzo `high` de forma predeterminada en la Claude API y Claude Code.

* **Esfuerzo high (predeterminado):** Adecuado para razonamiento complejo, programación y tareas agénticas donde la calidad importa más que la velocidad o el costo.
* **Esfuerzo xhigh:** Para las tareas de programación y agénticas más difíciles. Consulta [Prompting para Claude Sonnet 5](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-sonnet-5#calibrating-effort-and-thinking-depth).
* **Esfuerzo medium:** Reducción respecto al predeterminado para ahorrar costos. Comparable a Claude Sonnet 4.6 con esfuerzo alto.
* **Esfuerzo low:** Para cargas de trabajo de alto volumen o sensibles a la latencia. Adecuado para chat y casos de uso no relacionados con programación donde se prioriza una respuesta más rápida.
* **Esfuerzo max:** Para tareas que requieren la capacidad absolutamente más alta sin restricciones en el gasto de tokens.

### Niveles de esfuerzo recomendados para Claude Sonnet 4.6

Sonnet 4.6 usa esfuerzo `high` de forma predeterminada. Establece el esfuerzo explícitamente al usar Sonnet 4.6 para evitar una latencia inesperada:

* **Esfuerzo medium** (valor predeterminado recomendado): El mejor equilibrio entre velocidad, costo y rendimiento para la mayoría de las aplicaciones. Adecuado para programación agéntica, flujos de trabajo con uso intensivo de herramientas y generación de código.
* **Esfuerzo low:** Para cargas de trabajo de alto volumen o sensibles a la latencia. Adecuado para chat y casos de uso que no son de programación donde se prioriza una respuesta más rápida.
* **Esfuerzo high:** Para razonamiento complejo y tareas donde la calidad importa más que la velocidad o el costo.
* **Esfuerzo max:** Para tareas que requieren la máxima capacidad absoluta sin restricciones en el gasto de tokens.

### Niveles de esfuerzo recomendados para Claude Haiku 5.5

Claude Haiku 5.5 admite los cinco niveles de esfuerzo, y `medium` es el valor predeterminado. El esfuerzo es el control principal de cuánto piensa el modelo y, con ello, de la calidad, la latencia y el costo. **Empieza con `medium`** para la mayoría del trabajo, incluida la programación agéntica. Usa `low`, el nivel más barato y rápido, para chat, tareas cortas con herramientas y solicitudes simples de alto volumen. En prompts largos de agentes, es más probable que el modelo omita una búsqueda, se detenga antes de tiempo u omita una verificación en `low`. Usa `high` para trabajo de conocimiento, tareas de agente más largas y seguimiento estricto de instrucciones. Usa `xhigh` o `max` solo donde tus evaluaciones muestren una mejora de calidad, y compáralos con Claude Sonnet 5.5 en rendimiento, costo y velocidad. El pensamiento está activado de forma predeterminada y cuenta para `max_tokens`, así que deja espacio para él. Consulta [Cómo escribir prompts para Claude Haiku 5.5](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking).

Para obtener menos pensamiento, baja el nivel de esfuerzo. También puedes enviar `thinking: {"type": "disabled"}` con esfuerzo `high` o inferior. En `xhigh` o `max`, una solicitud con ese ajuste devuelve un error 400, así que usa pensamiento adaptativo en esos niveles: omite el campo `thinking` o envía `thinking: {"type": "adaptive"}`.

En la Claude API y Google Cloud, Claude Haiku 5.5 también admite [cambiar el esfuerzo a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/effort#change-effort-mid-conversation-beta) con un `output_config` por mensaje, lo que conserva la caché de prompts. Con `thinking: {"type": "disabled"}`, el esfuerzo no puede cambiar a mitad de la conversación: un `output_config.effort` por mensaje que difiera del nivel vigente devuelve un error 400. Para variar el esfuerzo por turno, usa pensamiento adaptativo.

## Esfuerzo con uso de herramientas

Al usar herramientas, el parámetro effort afecta tanto a las explicaciones en torno a las llamadas a herramientas como a las propias llamadas a herramientas. Los niveles de esfuerzo más bajos tienden a:

* Combinar múltiples operaciones en menos llamadas a herramientas
* Hacer menos llamadas a herramientas
* Proceder directamente a la acción sin preámbulo
* Usar mensajes de confirmación concisos tras completar

Los niveles de esfuerzo más altos pueden:

* Hacer más llamadas a herramientas
* Explicar el plan antes de actuar
* Proporcionar resúmenes detallados de los cambios
* Incluir comentarios de código más completos

## Esfuerzo con pensamiento

El parámetro `thinking` controla si Claude piensa en [bloques de pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking) antes de responder; el parámetro `effort` controla cuánto trabajo dedica Claude a la respuesta completa, lo que en modo adaptativo incluye con qué frecuencia y con qué profundidad piensa. No pases `adaptive` como valor de `effort`: `adaptive` es un modo de pensamiento, no un nivel de esfuerzo.

En niveles de esfuerzo más altos, Claude piensa con más facilidad y con mayor extensión. En un bucle de uso de herramientas, las solicitudes de seguimiento que solo procesan resultados de herramientas pueden omitir el pensamiento en cualquier nivel. En niveles más bajos, Claude puede omitir el pensamiento por completo en problemas más sencillos. Consulta [Pensamiento y esfuerzo](https://platform.claude.com/docs/es/build-with-claude/thinking#thinking-and-effort) para obtener una guía completa sobre cómo funcionan juntos ambos controles.

En Claude Opus 4.5, el único modelo exclusivo de "extended thinking" (pensamiento extendido) que admite esfuerzo, funciona junto con [`budget_tokens`](https://platform.claude.com/docs/es/build-with-claude/extended-thinking): establece el nivel de esfuerzo para tu tarea y luego establece el presupuesto de tokens de pensamiento según cuánta profundidad de razonamiento necesite la tarea.

Para la disponibilidad de pensamiento por modelo, consulta la [tabla de configuración por modelo](https://platform.claude.com/docs/es/build-with-claude/thinking-troubleshooting#supported-models). El esfuerzo funciona con o sin pensamiento. Consulta [Cómo funciona el esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort#how-effort-works).

## Cambiar el esfuerzo a mitad de la conversación

Puedes ejecutar turnos posteriores de una conversación con un nivel de esfuerzo diferente de dos maneras. En Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 y Claude Haiku 5.5, usa un cambio de esfuerzo por mensaje, que conserva la caché de prompts. En otros modelos, establece un nuevo valor de nivel superior en la siguiente solicitud, lo que reinicia la caché.

### Esfuerzo por mensaje (beta)

El esfuerzo por mensaje está en beta. En la Claude API y [Google Cloud](https://platform.claude.com/docs/es/build-with-claude/claude-on-vertex-ai), está disponible en Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 y Claude Haiku 5.5. En [Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock), está disponible en Claude Fable 5.1, Claude Mythos 5.1 y Claude Opus 5.5. Requiere el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers) `mid-conversation-output-config-2026-07-01`. Con la [API InvokeModel](https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy) de Amazon Bedrock, está disponible en Claude Fable 5.1 y Claude Opus 5.5, y en su lugar envías ese valor en el arreglo `anthropic_beta` del cuerpo de la solicitud.

Sin el valor beta, un `output_config` por mensaje devuelve un error 400: `messages.N.output_config: Extra inputs are not permitted`, donde `N` es el índice del mensaje `system` en `messages`. Con el valor beta, los modelos sin esfuerzo por mensaje, incluido Claude Fable 5, devuelven un error 400: `output_config.effort requires a model that supports per-turn effort; this model does not`. En Amazon Bedrock, esos modelos y Claude Opus 5 devuelven en su lugar el error `Extra inputs are not permitted`. En Claude Sonnet 5.5 con `thinking: {"type": "between_tools"}` y en Claude Haiku 5.5 con `thinking: {"type": "disabled"}`, el esfuerzo no puede cambiar a mitad de la conversación: un `output_config.effort` por mensaje que difiera del nivel vigente devuelve un error 400. Para variar el esfuerzo por turno, usa pensamiento adaptativo.

Añade un mensaje `role: "system"` con `content` vacío y el nuevo nivel en `output_config.effort`. Colocado directamente después de un turno `user` con nueva entrada, establece el nivel para la respuesta de Claude a ese turno. Colocado en cualquier otro lugar, como entre un turno `assistant` y el siguiente turno `user` como en el ejemplo siguiente, surte efecto a partir del siguiente turno `user` con nueva entrada. Un turno `user` que solo contiene bloques `tool_result` no cuenta como nueva entrada, por lo que un cambio colocado después de uno en un bucle de uso de herramientas espera al siguiente turno `user` con nueva entrada. El nuevo nivel se mantiene hasta que un mensaje posterior lo cambie. Todo lo anterior a ese mensaje permanece sin cambios, por lo que el prefijo en caché sigue coincidiendo.

El siguiente ejemplo empieza en `high` y luego baja a `low` para un seguimiento rutinario:

<CodeGroup>
  ```bash cURL
  # Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica desde el siguiente turno del usuario.
  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."
    # Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica desde el siguiente turno del usuario.
    - 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.",
          },
          # Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica desde el siguiente turno del usuario.
          {"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."
      },
      // Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica desde el siguiente turno del usuario.
      { 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." },
          // Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica desde el siguiente turno del usuario.
          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.")},
  		},
  		// Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica desde el siguiente turno del usuario.
  		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.")
          // Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica desde el siguiente turno del usuario.
          .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.'),
          // Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica desde el siguiente turno del usuario.
          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."},
      # Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica desde el siguiente turno del usuario.
      {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>

Un mensaje de sistema que solo contiene esfuerzo no lleva texto, por lo que las [reglas de ubicación para mensajes de sistema a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages#limitations) no se aplican. Puede aparecer en cualquier lugar de `messages`, incluso como la primera entrada o entre un turno `assistant` y el siguiente turno `user`. Los valores son los nombres de los niveles (`low`, `medium`, `high`, `xhigh` y `max`).

Prefiere esta forma en lugar de cambiar el valor de nivel superior entre solicitudes. Un cambio de nivel superior reinicia la caché y, en Claude Fable 5.1, también orienta al modelo de forma menos fiable: sus respuestas anteriores se escribieron con el nivel previo, y tiende a mantenerse coherente con ellas.

### Esfuerzo de nivel superior en la siguiente solicitud

El `output_config.effort` de nivel superior se aplica a toda la solicitud. Para ejecutar una parte posterior de una conversación con un nivel diferente, establece el nuevo valor en la siguiente solicitud. Dado que el esfuerzo de nivel superior da forma al prompt renderizado, cambiarlo entre solicitudes no preserva los prefijos en caché de turnos anteriores. Si dependes del [almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching) a lo largo de una sesión larga y tu modelo no admite esfuerzo por mensaje, elige un nivel de esfuerzo al inicio y mantenlo constante.

## Mejores prácticas

1. **Establece el esfuerzo explícitamente:** La API usa `high` de forma predeterminada (`medium` en Claude Opus 5.5 y Claude Haiku 5.5), pero el punto de partida adecuado depende de tu modelo y tu carga de trabajo.
2. **Usa low para tareas sensibles a la velocidad o sencillas:** Cuando la latencia importa o las tareas son sencillas, el esfuerzo bajo puede reducir significativamente los tiempos de respuesta y los costos.
3. **Prueba tu caso de uso:** El impacto de los niveles de esfuerzo varía según el tipo de tarea. Evalúa el rendimiento en tus casos de uso específicos antes de implementar.
4. **Considera un esfuerzo dinámico:** Ajusta el esfuerzo según la complejidad de la tarea. Las consultas simples pueden justificar un esfuerzo bajo, mientras que la programación agéntica y el razonamiento complejo se benefician de un esfuerzo alto. Consulta el siguiente punto antes de variarlo dentro de una misma conversación.
5. **Mantén constante el esfuerzo de nivel superior en conversaciones con caché:** Cambiar el valor de esfuerzo de nivel superior entre solicitudes invalida el [almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching), así que varíalo entre cargas de trabajo en lugar de dentro de una conversación que depende de aciertos de caché. En los modelos que lo admiten, usa en su lugar un [cambio de esfuerzo por mensaje](https://platform.claude.com/docs/es/build-with-claude/effort#change-effort-mid-conversation-beta), que conserva la caché. Consulta [Pensamiento y almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/thinking#thinking-and-prompt-caching).

## Próximos pasos

<CardGroup>
  <Card title="Presupuestos de tareas" icon="gauge" href="https://platform.claude.com/docs/es/build-with-claude/task-budgets">
    Dale a Claude un presupuesto de tokens orientativo para todo el bucle agéntico, lo que ayuda al modelo a autorregularse en tareas agénticas largas.
  </Card>

  <Card title="Dirigir el pensamiento" icon="compass" href="https://platform.claude.com/docs/es/build-with-claude/thinking-steering-and-cost">
    Comprende el pensamiento adaptativo, en el que Claude determina cuándo y cuánto pensar, y dirígelo con el esfuerzo y los prompts.
  </Card>

  <Card title="Pensamiento" icon="brain" href="https://platform.claude.com/docs/es/build-with-claude/thinking">
    Comprende cómo funciona el pensamiento, cuándo piensa Claude de forma predeterminada y cómo interactúa el pensamiento con el esfuerzo.
  </Card>
</CardGroup>