---
title: Pensamiento extendido
url: https://platform.claude.com/docs/es/build-with-claude/extended-thinking
description: Configura el pensamiento extendido manual con un presupuesto fijo de budget_tokens en los modelos de Claude que lo admiten, y migra al pensamiento adaptativo.
featureMetadata:
  supportedModels:
    - claude-mythos-preview
    - claude-haiku-4-5-20251001
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: stable
    Amazon Bedrock: stable
    Amazon Bedrock (bedrock-runtime): stable
    Claude Platform on AWS: stable
    Claude Models on Google Cloud (Anthropic managed): stable
    Claude Models on Google Cloud (Google managed): stable
    Microsoft Foundry: stable
---

<Warning>
  Pensamiento extendido es una función heredada.

  El pensamiento extendido (`thinking.type: "enabled"` con `budget_tokens`) está obsoleto. Los modelos Claude 4.7 y posteriores no lo admiten y rechazan las solicitudes que lo usan con un error 400.

  * Alternativa recomendada: [Pensamiento adaptativo](https://platform.claude.com/docs/es/build-with-claude/thinking-steering-and-cost)
  * Guía de migración: [Migrar al pensamiento adaptativo](https://platform.claude.com/docs/es/build-with-claude/extended-thinking#migrating-to-adaptive-thinking)
</Warning>

El “extended thinking” (pensamiento extendido) en modo manual te da control directo sobre cuánto piensa Claude. En cada solicitud estableces un presupuesto de tokens de pensamiento con `thinking: {type: "enabled", budget_tokens: N}`, y Claude piensa dentro de ese presupuesto antes de comenzar su respuesta final. El modo manual sigue siendo útil cuando tu carga de trabajo requiere una “latency” (latencia) predecible o un control preciso sobre los costos de pensamiento. Esta página explica cómo establecer y ajustar el presupuesto, cómo interactúa el modo manual con el “interleaved thinking” (pensamiento intercalado) y el “prompt caching” (almacenamiento en caché de prompts), y cómo migrar al “adaptive thinking” (pensamiento adaptativo).

Para aprender cómo funciona el pensamiento en sí, consulta [Pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking). Allí se explican los bloques de pensamiento y la forma de la respuesta, el parámetro `display`, el streaming, el pensamiento con “tool use” (uso de herramientas) y el cifrado.

## Modelos compatibles

La disponibilidad del pensamiento extendido para cada modelo, incluidos los modelos en los que el pensamiento extendido es el único modo, se indica en la [tabla de configuración por modelo](https://platform.claude.com/docs/es/build-with-claude/thinking-troubleshooting#supported-models).

## Cómo usar el pensamiento extendido

Este es un ejemplo de uso del pensamiento extendido en la Messages API:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-4-6",
      "max_tokens": 16000,
      "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
      },
      "messages": [
        {
          "role": "user",
          "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create --format yaml <<'YAML'
  model: claude-sonnet-4-6
  max_tokens: 16000
  thinking:
    type: enabled
    budget_tokens: 10000
  messages:
    - role: user
      content: Are there an infinite number of prime numbers such that n mod 4 == 3?
  YAML
  ```

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

  response = client.messages.create(
      model="claude-sonnet-4-6",
      max_tokens=16000,
      thinking={"type": "enabled", "budget_tokens": 10000},
      messages=[
          {
              "role": "user",
              "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?",
          }
      ],
  )

  # La respuesta contiene bloques de pensamiento resumidos y bloques de texto
  for block in response.content:
      match block.type:
          case "thinking":
              print(f"\nThinking summary: {block.thinking}")
          case "text":
              print(f"\nResponse: {block.text}")
  ```

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

  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 16000,
    thinking: {
      type: "enabled",
      budget_tokens: 10000
    },
    messages: [
      {
        role: "user",
        content: "Are there an infinite number of prime numbers such that n mod 4 == 3?"
      }
    ]
  });

  // La respuesta contiene bloques de pensamiento resumidos y bloques de texto
  for (const block of response.content) {
    switch (block.type) {
      case "thinking":
        console.log(`\nThinking summary: ${block.thinking}`);
        break;
      case "text":
        console.log(`\nResponse: ${block.text}`);
        break;
    }
  }
  ```

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

  var response = await client.Messages.Create(new()
  {
      Model = Model.ClaudeSonnet4_6,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
      Messages =
      [
          new UserMessageParam
          {
              Content = "Are there an infinite number of prime numbers such that n mod 4 == 3?",
          },
      ],
  });

  // La respuesta contiene bloques de pensamiento resumidos y bloques de texto
  foreach (var block in response.Content)
  {
      if (block.TryPickThinking(out var thinking))
      {
          Console.WriteLine($"\nThinking summary: {thinking.Thinking}");
      }
      else if (block.TryPickText(out var text))
      {
          Console.WriteLine($"\nResponse: {text.Text}");
      }
  }
  ```

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

  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet4_6,
  	MaxTokens: 16000,
  	Thinking:  anthropic.ThinkingConfigParamOfEnabled(10000),
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Are there an infinite number of prime numbers such that n mod 4 == 3?")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  // La respuesta contiene bloques de pensamiento resumidos y bloques de texto
  for _, block := range response.Content {
  	switch block := block.AsAny().(type) {
  	case anthropic.ThinkingBlock:
  		fmt.Printf("\nThinking summary: %s", block.Thinking)
  	case anthropic.TextBlock:
  		fmt.Printf("\nResponse: %s", block.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.models.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

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

      var params = MessageCreateParams.builder()
          .model(Model.CLAUDE_SONNET_4_6)
          .maxTokens(16_000)
          .enabledThinking(10_000)
          .addUserMessage("Are there an infinite number of prime numbers such that n mod 4 == 3?")
          .build();

      var response = client.messages().create(params);

      // La respuesta contiene bloques de pensamiento resumidos y bloques de texto
      for (var block : response.content()) {
          block.thinking().ifPresent(thinkingBlock ->
              IO.println("\nThinking summary: " + thinkingBlock.thinking())
          );
          block.text().ifPresent(textBlock ->
              IO.println("\nResponse: " + textBlock.text())
          );
      }
  }
  ```

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

  $response = $client->messages->create(
      model: 'claude-sonnet-4-6',
      maxTokens: 16000,
      thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
      messages: [
          [
              'role' => 'user',
              'content' => 'Are there an infinite number of prime numbers such that n mod 4 == 3?',
          ],
      ],
  );

  // La respuesta contiene bloques de pensamiento resumidos y bloques de texto
  foreach ($response->content as $block) {
      echo match (true) {
          $block instanceof \Anthropic\Messages\ThinkingBlock => "\nThinking summary: {$block->thinking}",
          $block instanceof \Anthropic\Messages\TextBlock => "\nResponse: {$block->text}",
          default => '',
      };
  }
  ```

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

  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_4_6,
    max_tokens: 16_000,
    thinking: {
      type: :enabled,
      budget_tokens: 10_000
    },
    messages: [
      {
        role: :user,
        content: "Are there an infinite number of prime numbers such that n mod 4 == 3?"
      }
    ]
  )

  # La respuesta contiene bloques de pensamiento resumidos y bloques de texto
  response.content.each do |block|
    case block
    when Anthropic::Models::ThinkingBlock
      puts "\nThinking summary: #{block.thinking}"
    when Anthropic::Models::TextBlock
      puts "\nResponse: #{block.text}"
    end
  end
  ```
</CodeGroup>

Para activar el pensamiento extendido manual, agrega un objeto `thinking` con `type` establecido en `enabled` y un valor de `budget_tokens`.

El parámetro `budget_tokens` establece un objetivo de cuántos tokens puede usar Claude para su proceso de razonamiento interno. Los presupuestos más grandes pueden mejorar la calidad de la respuesta al permitir un análisis más exhaustivo de problemas complejos.

## Reglas y ajuste del presupuesto

`budget_tokens` debe cumplir estas restricciones:

* **Mínimo de 1,024 tokens.** La API rechaza valores más pequeños.
* **Menor que `max_tokens`.** Los tokens de pensamiento cuentan para el límite de `max_tokens` del turno, por lo que el presupuesto debe dejar espacio para la respuesta final. La única excepción es el [pensamiento intercalado en modo manual](https://platform.claude.com/docs/es/build-with-claude/extended-thinking#interleaved-thinking), donde `budget_tokens` puede superar `max_tokens` porque el presupuesto abarca todos los bloques de pensamiento dentro de un turno del asistente.
* **Sin precalentamiento de caché.** Como `budget_tokens` debe ser menor que `max_tokens`, el pensamiento extendido no se puede combinar con `max_tokens: 0` ([precalentamiento de caché](https://platform.claude.com/docs/es/build-with-claude/prompt-caching#pre-warming-the-cache)).

El presupuesto es un objetivo y no un límite estricto. El uso real de tokens varía según la tarea, y Claude podría dejar de razonar mucho antes de agotar el presupuesto; `max_tokens` sigue siendo el tope absoluto de la salida total.

En Claude Opus 4.5, el único modelo exclusivamente de pensamiento extendido que admite [esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort), el esfuerzo moldea la respuesta general, mientras que `budget_tokens` establece la profundidad del pensamiento; establece ambos.

Para ajustar el presupuesto:

* Adapta el punto de partida a la tarea. Para tareas simples, comienza cerca del mínimo de 1,024 tokens y aumenta gradualmente para encontrar el rango óptimo para tu caso de uso. Para tareas complejas, comienza con un presupuesto mayor, de 16,000 tokens o más, y ajústalo según tus necesidades de latencia y calidad. Los presupuestos más altos permiten un razonamiento más completo, con rendimientos decrecientes que dependen de la tarea y a costa de una mayor latencia. Para tareas críticas, prueba diferentes configuraciones para encontrar el equilibrio adecuado.
* Para presupuestos de pensamiento superiores a 32k, usa el [procesamiento por lotes](https://platform.claude.com/docs/es/build-with-claude/batch-processing) para evitar problemas de red. Si haces que el modelo piense más allá de 32k tokens, las solicitudes tardan mucho y pueden alcanzar los tiempos de espera del sistema y los límites de conexiones abiertas.

Para saber cuánto te cuesta realmente un presupuesto, supervisa el campo `usage.output_tokens_details.thinking_tokens` de la respuesta. Este campo indica cuántos de los tokens de salida facturados correspondieron a razonamiento interno. Con streaming, este desglose solo aparece en el evento final `message_delta`.

Cuando estés listo para dejar los presupuestos manuales, consulta [Migrar al pensamiento adaptativo](https://platform.claude.com/docs/es/build-with-claude/extended-thinking#migrating-to-adaptive-thinking).

## Pensamiento intercalado en modo manual

El pensamiento intercalado permite que Claude piense entre llamadas a herramientas dentro de un solo turno del asistente, razonando sobre cada resultado de herramienta antes de determinar qué hacer a continuación. Para conocer el concepto, la estructura de turnos y cómo se comporta en los modelos con pensamiento adaptativo, consulta [pensamiento intercalado](https://platform.claude.com/docs/es/build-with-claude/thinking#interleaved-thinking) en la descripción general del pensamiento. Esta sección explica cómo habilitarlo cuando usas el pensamiento manual `type: "enabled"`.

En Claude Opus 4.5, Claude Sonnet 4.5 (obsoleto) y modelos Claude 4 anteriores, agrega el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers) `interleaved-thinking-2025-05-14` a tu solicitud de API.

En la generación 4.6, el modo manual se comporta de forma distinta según el modelo:

* **Claude Sonnet 4.6**: el encabezado beta con `type: "enabled"` manual todavía funciona, pero está obsoleto. Es preferible usar el [pensamiento adaptativo](https://platform.claude.com/docs/es/build-with-claude/thinking), que intercala automáticamente sin necesidad del encabezado.
* **Claude Opus 4.6**: el modo manual no admite pensamiento intercalado. Solo su modo adaptativo intercala, así que cambia a `thinking: {type: "adaptive"}` si necesitas razonamiento entre llamadas a herramientas en este modelo.

Claude Haiku 4.5 no admite pensamiento intercalado. En la Claude API, el encabezado beta se acepta, pero se ignora.

Ten en cuenta dos consideraciones más sobre el pensamiento intercalado en modo manual:

* Aquí `budget_tokens` puede superar `max_tokens`. Las [reglas del presupuesto](https://platform.claude.com/docs/es/build-with-claude/extended-thinking#budget-rules-and-tuning) explican esta excepción.
* El pensamiento intercalado solo es compatible con las [herramientas usadas a través de la Messages API](https://platform.claude.com/docs/es/agents-and-tools/tool-use/overview).

La forma en que las plataformas tratan el encabezado beta difiere. La Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws) y [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed) aceptan `interleaved-thinking-2025-05-14` en cualquier modelo y lo ignoran donde no es compatible. Aceptarlo no es lo mismo que tener efecto: en los modelos que rechazan `type: "enabled"` (4.7 y posteriores) o que carecen de intercalado en modo manual (Claude Opus 4.6), el encabezado no tiene efecto en modo manual; allí, el pensamiento adaptativo intercala automáticamente.

Las plataformas operadas por socios, [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed) y [Amazon Bedrock (`bedrock-mantle`)](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock), aceptan el encabezado en cualquier modelo sin devolver un error, y lo ignoran en los modelos que no admiten el pensamiento intercalado.

## Estructura del turno en modo manual

Las reglas generales de estructura del turno se encuentran en [Pensamiento con uso de herramientas](https://platform.claude.com/docs/es/build-with-claude/thinking#thinking-with-tool-use). Allí se explican el bucle de uso de herramientas en un solo turno, el manejo de conflictos a mitad del turno y la activación o desactivación del pensamiento entre turnos.

El modo manual agrega un requisito: el turno final del asistente de una solicitud con pensamiento habilitado debe comenzar con un bloque de pensamiento (el [pensamiento adaptativo](https://platform.claude.com/docs/es/build-with-claude/thinking) elimina ese requisito). Cambiar la configuración del pensamiento entre turnos también invalida el almacenamiento en caché de prompts; consulta la sección siguiente.

## Almacenamiento en caché de prompts en modo manual

El modo manual agrega una regla al comportamiento de almacenamiento en caché común a ambos modos, descrito en [pensamiento y almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/thinking#thinking-and-prompt-caching). Cambiar `budget_tokens` entre solicitudes invalida los puntos de interrupción de caché, igual que cambiar de modo de pensamiento, porque el valor del presupuesto se incluye en el prompt. Los puntos de interrupción a nivel de mensaje siempre fallan después de un cambio de presupuesto. Que también fallen los puntos de interrupción de herramientas y de la indicación del sistema depende de dónde incluya el modelo la configuración.

En la práctica, elige un presupuesto y mantenlo estable durante toda la conversación almacenada en caché. Por ejemplo, en una conversación de varios turnos con almacenamiento en caché a nivel de mensaje en Claude Sonnet 4.6, cambiar el presupuesto de 4,000 a 8,000 tokens en la tercera solicitud muestra la invalidación directamente:

```text Output wrap
First request - establishing cache
First response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Second request - same thinking parameters (cache hit expected)
Second response usage: { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Third request - different thinking budget (cache miss expected)
Third response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }
```

La tercera solicitud vuelve a crear la caché (`cache_creation_input_tokens=1370`, `cache_read_input_tokens=0`) porque el presupuesto cambió entre solicitudes. En el modo adaptativo, el nivel de esfuerzo cumple en la caché el papel que aquí cumple `budget_tokens`. Para ver una versión ejecutable del mismo experimento en ese modo, consulta [Almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/thinking-steering-and-cost#prompt-caching) en la página sobre cómo dirigir el pensamiento.

## Mecánicas compartidas

La mayor parte del comportamiento del pensamiento es común a ambos modos y se documenta una sola vez en la página de [Pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking). Estas secciones también se aplican al modo manual:

* [Controlar la visualización del pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking#controlling-thinking-display)
* [Streaming del pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking#streaming-thinking)
* [Pensamiento con uso de herramientas](https://platform.claude.com/docs/es/build-with-claude/thinking#thinking-with-tool-use), incluida la [preservación de bloques de pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking#preserving-thinking-blocks)
* [Pensamiento y almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/thinking#thinking-and-prompt-caching)
* [Pensamiento y la ventana de contexto](https://platform.claude.com/docs/es/build-with-claude/thinking#thinking-and-the-context-window)
* [Cifrado del pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking#thinking-encryption)
* [Precios](https://platform.claude.com/docs/es/build-with-claude/thinking-steering-and-cost#pricing) (en la página [Dirigir el pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking-steering-and-cost))

## Migrar al pensamiento adaptativo

Si tu modelo solo admite pensamiento extendido, no necesitas hacer nada. Estos modelos son Claude Sonnet 4.5 (obsoleto), Claude Opus 4.5, Claude Haiku 4.5 y modelos Claude 4 anteriores. El pensamiento adaptativo no está disponible en ellos, y `type: "adaptive"` [devuelve un error 400](https://platform.claude.com/docs/es/build-with-claude/thinking-troubleshooting#error-thinking-type-adaptive). Mantén `budget_tokens` hasta que pases a un modelo que admita pensamiento adaptativo y, luego, aplica la correspondencia que se indica a continuación.

Necesitas dejar de usar `type: "enabled"` si:

* Usas Claude Opus 4.6 o Claude Sonnet 4.6, donde `budget_tokens` está obsoleto.
* Usas un modelo numerado 4.7 o superior, donde `type: "enabled"` devuelve un error 400. Algunos ejemplos son Claude Opus 5.5, Claude Sonnet 5, Claude Sonnet 5.5, Claude Fable 5.2, Claude Fable 5.1 y Claude Haiku 5.5.

La correspondencia es sencilla: elimina `budget_tokens`, establece `thinking: {type: "adaptive"}` y controla la profundidad del razonamiento con `output_config: {effort: ...}` en lugar de un presupuesto de tokens.

```json
{
  "model": "claude-sonnet-4-6",
  "max_tokens": 16000,
  "thinking": {
    "type": "enabled",
    "budget_tokens": 10000
  }
}
```

se convierte en:

```json
{
  "model": "claude-sonnet-4-6",
  "max_tokens": 16000,
  "thinking": {
    "type": "adaptive"
  },
  "output_config": {
    "effort": "high"
  }
}
```

`effort: "high"` es el valor predeterminado en Claude Sonnet 4.6, por lo que omitirlo aquí produce un comportamiento idéntico; aparece solo para mostrar dónde se encuentra el control de profundidad en modo adaptativo. Claude Opus 5.5 y Claude Haiku 5.5 usan `"medium"` de forma predeterminada, y otros modelos que admiten esfuerzo usan `"high"` de forma predeterminada (consulta [Niveles de esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort#effort-levels)).

Espera una diferencia de comportamiento, no solo un cambio de sintaxis. Con un presupuesto fijo, Claude piensa en cada solicitud. Con el pensamiento adaptativo, Claude determina si pensar y cuánto en cada solicitud, y con configuraciones de [esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort) más bajas podría omitir por completo el pensamiento en entradas sencillas. También puedes eliminar el encabezado beta `interleaved-thinking-2025-05-14` después de migrar: el pensamiento adaptativo intercala automáticamente, y la Claude API ignora el encabezado en estos modelos. La preservación de bloques de pensamiento también cambia. Claude Opus 4.5 y los modelos numerados 4.6 y superiores mantienen en contexto los bloques de pensamiento de turnos anteriores y los facturan como entrada. Claude Sonnet 4.5 (obsoleto), Claude Haiku 4.5 y los modelos anteriores los eliminan. Consulta [preservación de bloques de pensamiento por modelo](https://platform.claude.com/docs/es/build-with-claude/thinking#thinking-block-preservation-by-model).

Cambiar de modo es un cambio en la configuración del pensamiento. Por eso, la primera solicitud después del cambio invalida los puntos de interrupción de caché, como se describe en [Almacenamiento en caché de prompts en modo manual](https://platform.claude.com/docs/es/build-with-claude/extended-thinking#extended-thinking-with-prompt-caching).

Para obtener orientación completa, consulta [Pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking), [Esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort) y [Guías de migración](https://platform.claude.com/docs/es/about-claude/models/migration-guide).

## Próximos pasos

<CardGroup cols={3}>
  <Card title="Pensamiento" icon="brain" href="https://platform.claude.com/docs/es/build-with-claude/thinking">
    Aprende cómo funciona el pensamiento: bloques, visualización, streaming y uso de herramientas.
  </Card>

  <Card title="Dirigir el pensamiento" icon="compass" href="https://platform.claude.com/docs/es/build-with-claude/thinking-steering-and-cost">
    Deja que Claude determine cuándo y cuánto pensar en cada solicitud.
  </Card>

  <Card title="Pensamiento en flujos de trabajo con herramientas y de múltiples turnos" icon="wrench" href="https://platform.claude.com/docs/es/build-with-claude/thinking-tool-workflows">
    Preserva los bloques de pensamiento y gestiona el pensamiento a lo largo de llamadas a herramientas y turnos.
  </Card>
</CardGroup>

## Disponibilidad

Pensamiento extendido está disponible o en desuso en algunos modelos.

### Compatibilidad con la API

#### [Messages API](https://platform.claude.com/docs/es/build-with-claude/working-with-messages)

* Disponibilidad: Disponible

| Estado     | Modelos                                                                                                                                                                                                                                                                        |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Disponible | Claude Mythos Preview, [Claude Haiku 4.5](https://platform.claude.com/docs/es/models/haiku-4-5/overview), [Claude Opus 4.5](https://platform.claude.com/docs/es/models/opus-4-5/overview), [Claude Sonnet 4.5](https://platform.claude.com/docs/es/models/sonnet-4-5/overview) |
| En desuso  | [Claude Opus 4.6](https://platform.claude.com/docs/es/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/es/models/sonnet-4-6/overview)                                                                                                           |

#### [Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview)

* Disponibilidad: No disponible
* Uso: En los modelos Claude 4.5, Managed Agents activa por sí mismo el pensamiento manual con un presupuesto fijo que no puedes cambiar. En los modelos más recientes usa el pensamiento adaptativo. Usa [Esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort) en su lugar.
