---
title: Guía de migración a Claude Opus 5.5
url: https://platform.claude.com/docs/es/models/opus-5-5/migration-guide
description: Cambia a Claude Opus 5.5 desde modelos Opus anteriores o desde Claude Sonnet 5 con esta guía de migración. La guía para habilitar Claude Opus 5.5 incluye los ajustes de solicitud que devuelven errores, los bloques de pensamiento en cada respuesta y una lista de verificación para cada modelo de partida.
---
Esta guía cubre la migración de código de la [Messages API](https://platform.claude.com/docs/es/build-with-claude/working-with-messages). Si usas [Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview), no se requieren cambios más allá de actualizar el nombre del modelo.
**Automatiza tu migración con la skill de Claude API.** En Claude Code, ejecuta `/claude-api migrate` para invocar la [skill de Claude API](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) incluida. Funciona con cualquier modelo actual de Claude como destino:
Deja que Claude Code migre tu código por ti
```text
/claude-api migrate este proyecto a claude-opus-5-5
```
La skill aplica el cambio de ID de modelo y, según sea necesario, los cambios de parámetros incompatibles, el reemplazo de prefill y la calibración de esfuerzo para tu modelo de destino en toda tu base de código, y luego produce una lista de verificación de elementos para revisar manualmente. Te pide que confirmes el alcance de la migración (todo el directorio de trabajo, un subdirectorio o una lista específica de archivos) antes de editar cualquier archivo. La skill también detecta clientes de Amazon Bedrock y Claude Platform on AWS y ajusta los formatos de ID de modelo y los cambios de funcionalidades para esas plataformas.
Esta página enumera los cambios de código necesarios para pasar a Claude Opus 5.5 desde [Claude Opus 5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-5), [Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8), [Claude Opus 4.7](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-47), [Claude Opus 4.6 y modelos Opus anteriores](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-46) o [Claude Sonnet 5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-sonnet-5). Todos los lectores necesitan [Lo que debe cumplir cada solicitud a Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#request-requirements) y [Gestiona el pensamiento en cada respuesta](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-in-every-response). Después, ve a la sección de tu modelo actual: su primera oración indica las demás secciones que te corresponden. La [lista de verificación de migración](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migration-checklist) enumera cada cambio según el modelo de partida.
Claude Opus 5.5 cuesta menos que Claude Opus 5 ($4 / $20 USD por millón de tokens de entrada / salida, frente a $5 / $25; consulta [Precios de Claude](https://platform.claude.com/docs/es/about-claude/pricing)). Para conocer la compatibilidad de funciones, consulta [Novedades de Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/whats-new-opus-5-5#feature-support). Para conocer las diferencias de comportamiento y los patrones de prompting específicos del modelo, 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).
## Lo que debe cumplir cada solicitud a Claude Opus 5.5
Sin importar de qué modelo vengas, una solicitud a `claude-opus-5-5` debe cumplir lo siguiente. Cuando un elemento indica que un ajuste se rechaza, la API devuelve un error 400.
* **ID del modelo:** Usa `claude-opus-5-5`, un ID de modelo fijo sin sufijo de fecha. En Amazon Bedrock, Claude Platform on AWS, Google Cloud y Microsoft Foundry, usa el ID de modelo de esa plataforma; consulta [Disponibilidad](https://platform.claude.com/docs/es/models/opus-5-5/whats-new-opus-5-5#availability).
* **Pensamiento:** No envíes ningún campo `thinking`, o envía `thinking: {"type": "adaptive"}`, que es equivalente: el ["adaptive thinking" (pensamiento adaptativo)](https://platform.claude.com/docs/es/build-with-claude/thinking) siempre está activado. `thinking: {"type": "disabled"}` y los presupuestos de pensamiento manuales (`thinking: {"type": "enabled", "budget_tokens": N}`) se rechazan. Consulta el [antes y después para el pensamiento](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-cant-be-disabled).
* **Esfuerzo:** Controla la profundidad del pensamiento con el [parámetro "effort" (esfuerzo)](https://platform.claude.com/docs/es/build-with-claude/effort), el único parámetro de solicitud que la controla. Se admiten los cinco niveles (`low`, `medium`, `high`, `xhigh`, `max`), y el valor predeterminado es `medium`. Consulta [Niveles de esfuerzo recomendados para Claude Opus 5.5](https://platform.claude.com/docs/es/build-with-claude/effort#recommended-effort-levels-for-claude-opus-5-5).
* **Elección de herramienta:** Usa `tool_choice` `{"type": "auto"}` (el valor predeterminado) o `{"type": "none"}`. Forzar una llamada a herramienta con `{"type": "any"}` o `{"type": "tool", "name": "..."}` se rechaza. Consulta el [antes y después para la elección de herramienta](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#forced-tool-use).
* **Parámetros de muestreo:** Omite `temperature`, `top_p` y `top_k`, o déjalos en sus valores predeterminados: cualquier otro valor se rechaza. Usa el prompting para guiar el comportamiento del modelo.
* **Prefill:** No termines `messages` con un turno de asistente con "prefill" (prellenado): se rechaza. Usa [salidas estructuradas](https://platform.claude.com/docs/es/build-with-claude/structured-outputs) o instrucciones en la indicación del sistema en su lugar. En Amazon Bedrock, las salidas estructuradas no están disponibles para Claude Opus 5.5, así que usa allí instrucciones en la indicación del sistema.
* **Uso de computadora:** En la Claude API y Google Cloud, declara el uso de computadora como el conjunto de herramientas `computer_toolset_20260801`; la herramienta anterior `computer_20251124` se rechaza allí. Consulta el [cambio incompatible del uso de computadora](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#computer-use-toolset).
* **Ventana de contexto:** No se necesita ningún encabezado beta de "context window" (ventana de contexto). La [ventana de contexto de 1M de tokens](https://platform.claude.com/docs/es/build-with-claude/context-windows) es la predeterminada, y un encabezado enviado para modelos anteriores no tiene efecto.
La siguiente solicitud cumple todos los elementos de la lista: el esfuerzo está establecido y no hay ningún campo `thinking`. Las pestañas de SDK que imprimen texto lo seleccionan por tipo de bloque, porque los bloques `thinking` aparecen primero.
```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"}'
```
```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
```
## Gestiona el pensamiento en cada respuesta
El pensamiento se ejecuta en cada solicitud a Claude Opus 5.5, por lo que cada respuesta puede comenzar con bloques `thinking`, y `max_tokens` abarca el pensamiento más el texto. Si tu código ya se ejecuta con el pensamiento activado, es probable que los elementos 1 a 3 ya estén resueltos: revisa los elementos 4 y 5. Si se ejecutaba sin pensamiento, en cualquier modelo anterior, cada elemento es un cambio.
1. **`max_tokens` abarca el pensamiento más el texto:** En Claude Opus 4.8 y modelos Opus anteriores, las solicitudes sin un campo `thinking` se ejecutan sin pensamiento. Claude Opus 5 y Claude Sonnet 5 aceptan `thinking: {"type": "disabled"}`. En Claude Opus 5.5, cada solicitud se ejecuta con [pensamiento adaptativo](https://platform.claude.com/docs/es/build-with-claude/thinking). `max_tokens` sigue siendo un límite estricto sobre la salida total, pensamiento más texto de respuesta, así que revísalo para las cargas de trabajo que se ejecutaban sin pensamiento. Los tokens de pensamiento se facturan como tokens de salida incluso cuando el texto del pensamiento no se te devuelve, por lo que una carga de trabajo así puede producir más tokens de salida por solicitud. Consulta [Control de costos](https://platform.claude.com/docs/es/build-with-claude/thinking-steering-and-cost#cost-control). Para gastar menos tokens en pensamiento, reduce el nivel de [esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort). Si ejecutas con esfuerzo `xhigh` o `max`, establece un `max_tokens` grande para que el modelo tenga espacio para pensar y actuar; comienza con 64k tokens y ajusta a partir de ahí. Si tus prompts estaban ajustados para ejecutarse sin pensamiento, consulta [Prompts escritos para el pensamiento desactivado](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#prompts-written-for-thinking-disabled).
2. **Las respuestas comienzan con bloques de pensamiento:** Una respuesta puede comenzar con uno o más bloques `thinking` antes del primer bloque `text`. El código que lee la respuesta por posición, como `content[0].text` o un manejador de streaming que trata el primer evento `content_block_start` como texto, falla con estas respuestas. En su lugar, selecciona los bloques de contenido por su campo `type`: lee `text` de los bloques cuyo `type` es `"text"`, y ramifica según el tipo de bloque al manejar los eventos de streaming.
3. **Devuelve los bloques de pensamiento sin modificar en los bucles de uso de herramientas:** Si ejecutas un bucle de "tool use" (uso de herramientas), devuelve a la API los bloques `thinking` de cada respuesta del asistente completos y sin modificar cuando devuelvas los resultados de las herramientas, incluidos los bloques cuyo campo `thinking` está vacío. Reenvía el mensaje del asistente tal como lo recibiste en lugar de filtrar sus bloques de contenido por tipo o reconstruirlo: la API rechaza con un error 400 los bloques de pensamiento editados, reordenados o eliminados parcialmente. Consulta [Preservar los bloques de pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking#preserving-thinking-blocks).
4. **El texto del pensamiento se omite de forma predeterminada:** `thinking.display` tiene como valor predeterminado `"omitted"`, por lo que los bloques `thinking` llegan con un campo `thinking` vacío junto con su `signature`. Trata el campo `thinking` solo como texto para mostrar. Para recibir resúmenes legibles en su lugar, establece `thinking.display` en `"summarized"`:
```python Python
thinking = {
"type": "adaptive",
"display": "summarized",
}
```
```typescript TypeScript
const thinking = {
type: "adaptive",
display: "summarized"
};
```
```csharp C#
var thinking = new ThinkingConfigAdaptive { Display = Display.Summarized };
```
```go Go
thinking := anthropic.ThinkingConfigParamUnion{
OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{
Display: anthropic.ThinkingConfigAdaptiveDisplaySummarized,
},
}
```
```java Java
ThinkingConfigAdaptive thinking = ThinkingConfigAdaptive.builder()
.display(ThinkingConfigAdaptive.Display.SUMMARIZED)
.build();
```
```php PHP
$thinking = ['type' => 'adaptive', 'display' => 'summarized'];
```
```ruby Ruby
thinking = {
type: "adaptive",
display: "summarized"
}
```
Si tu producto transmite el razonamiento a los usuarios mediante streaming, el valor predeterminado aparece como una pausa larga antes de que comience la salida; establece `display: "summarized"` para restaurar el progreso visible durante el pensamiento. Consulta [Controlar la visualización del pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking#controlling-thinking-display).
5. **El texto entre llamadas a herramientas llega en bloques de pensamiento:** Las notas breves que el modelo escribe entre llamadas a herramientas se devuelven como bloques `thinking`, que están vacíos con la visualización predeterminada. Consulta [El texto entre llamadas a herramientas se devuelve en bloques de pensamiento](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#text-between-tool-calls).
## Lista de verificación de migración por modelo de partida
Recorre los grupos en orden y detente después del que nombra tu modelo actual: todos los elementos hasta ese punto te corresponden. Si estás en Claude Opus 5, el primer grupo es la lista completa. Si estás en Claude Sonnet 5, aplica el primer grupo y el último.
### Todos los modelos de partida
* Actualiza el ID del modelo a `claude-opus-5-5`.
* Elimina `thinking: {"type": "disabled"}` y `thinking: {"type": "enabled", ...}`; elige un nivel de esfuerzo en su lugar.
* Configura `effort` explícitamente: el valor predeterminado es `medium`, mientras que el de Claude Opus 5 es `high`.
* Reemplaza los tipos de `tool_choice` `any` y `tool` por `auto` más uso estricto de herramientas o salidas estructuradas, o solo por `auto` en Amazon Bedrock.
* Si usas el uso de computadora en la Claude API o Google Cloud, declara `computer_toolset_20260801` (sin encabezado beta) en lugar de `computer_20251124` y actualiza tu bucle de agente para el conjunto de herramientas. En Amazon Bedrock, mantén `computer_20251124`; consulta la sección [Compatibilidad](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool#compatibility) de la herramienta de uso de computadora para otras plataformas.
* Si un enrutador o un fallback puede mover una conversación de Claude Opus 5.5 a otro modelo, espera que ese modelo se ejecute sin los bloques de pensamiento de Claude Opus 5.5 (Claude Fable 5.1 y Claude Mythos 5.1 en la Claude API son la excepción y los conservan). Claude Opus 5.5 en sí lee el pensamiento de Claude Opus 5, de modelos Opus, Sonnet y Haiku anteriores y, en la Claude API y Google Cloud, de Claude Sonnet 5.5 y Claude Haiku 5.5, pero no de los modelos Claude Fable ni Claude Mythos.
* Lee los bloques de contenido por `type` y pasa los bloques `thinking` de vuelta sin modificar en los bucles de uso de herramientas.
* Si tu interfaz muestra el texto entre llamadas a herramientas, configura `display: "updates"` (beta) o `"summarized"` y muestra los bloques `thinking` que no estén vacíos.
* Si tu código edita turnos anteriores, la indicación `system` o `tools` a mitad de la conversación, sigue [Pensamiento preservado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking).
* Gestiona `stop_reason: "refusal"` y configura el fallback.
* Vuelve a establecer la línea base de costo y latencia en el nivel de esfuerzo que elijas.
* Si tu código desactivaba el pensamiento, revisa `max_tokens`, que cubre el pensamiento más el texto de respuesta; con esfuerzo `xhigh` o `max`, comienza con 64k. Consulta [Gestiona el pensamiento en cada respuesta](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-in-every-response).
### Claude Opus 4.8 o anterior
* Revisa las cargas de trabajo que se ejecutaban sin un campo `thinking`: en Claude Opus 5.5 se ejecutan con pensamiento, y el pensamiento no se puede desactivar. Revisa `max_tokens`, que sigue siendo un límite estricto sobre la salida total (pensamiento más texto de respuesta), y reduce `effort` donde quieras menos pensamiento. Los tokens de pensamiento se facturan como tokens de salida, por lo que estas cargas de trabajo pueden producir más tokens de salida por solicitud.
* Verifica que cualquier código que analice el campo `thinking` lo trate solo como texto para mostrar. Establece `display: "summarized"` para recibir resúmenes legibles.
* Revisa los prompts cercanos al mínimo de caché: los prompts de 512 tokens o más pueden crear entradas de caché.
* Si tu organización tiene un compromiso de [Priority Tier](https://platform.claude.com/docs/es/api/service-tiers#supported-models), planifica la capacidad por separado: Priority Tier no es compatible con Claude Opus 5.5.
* Si ejecutas con esfuerzo `xhigh` o `max`, aumenta `max_tokens` a al menos 64k como punto de partida.
* Para cargas de trabajo agénticas, considera los [presupuestos de tareas](https://platform.claude.com/docs/es/build-with-claude/task-budgets) (beta) y los cambios de herramientas a mitad de la conversación (beta).
### Claude Opus 4.7 o anterior
* Ejecuta un nuevo barrido de [esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort) con tus propias evaluaciones en lugar de trasladar una configuración ajustada para un modelo anterior.
* Elimina cualquier encabezado beta de ventana de contexto.
* Si reconstruyes el historial de la conversación para actualizar instrucciones, considera cambiar a un mensaje del sistema a mitad de la conversación para preservar los aciertos de la caché de prompts.
* Verifica que tu manejo de motivos de detención lea `stop_details` en los rechazos.
* Si quieres el modo rápido, que Claude Opus 4.7 rechaza, establece `speed: "fast"` en tus solicitudes a la Claude API. Claude Opus 5.5 no necesita un encabezado beta.
### Claude Opus 4.6 o anterior
* Elimina `temperature`, `top_p` y `top_k` de los cuerpos de las solicitudes.
* Reemplaza `thinking: {"type": "enabled", "budget_tokens": N}` por `thinking: {"type": "adaptive"}` más el [parámetro effort](https://platform.claude.com/docs/es/build-with-claude/effort), o elimina por completo el campo `thinking`; el pensamiento adaptativo siempre está activado.
* Si tu interfaz muestra el contenido del pensamiento, activa explícitamente el resumen del pensamiento.
* Vuelve a medir el costo y la latencia de extremo a extremo con la tokenización actualizada.
* Vuelve a ajustar `max_tokens` para tener en cuenta la tokenización actualizada, incluidos los disparadores de compactación.
* Vuelve a probar cualquier estimación de conteo de tokens del lado del cliente.
* Si tu aplicación envía imágenes, vuelve a presupuestar para la [compatibilidad con imágenes de alta resolución](https://platform.claude.com/docs/es/build-with-claude/vision#high-resolution-image-support-on-claude-opus-4-7) (hasta aproximadamente 3 veces más tokens de imagen por imagen a resolución completa). Reduce la resolución antes de enviar si no necesitas la fidelidad adicional.
* Si consumes coordenadas de señalamiento o de cuadros delimitadores del modelo, elimina cualquier conversión por factor de escala; las coordenadas son 1:1 con los píxeles reales de la imagen en Claude Opus 4.7 y modelos posteriores.
* Revisa los [cambios de comportamiento](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#behavior-changes) que comenzaron en Claude Opus 4.7.
* Si tu producto realiza trabajo legítimo de seguridad, solicita acceso al [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) para obtener restricciones menores sobre contenido cibernético.
### Claude Opus 4.5 o anterior
* Elimina cualquier prefill de mensajes del asistente; Claude Opus 4.6 ya los rechaza.
* Verifica que el análisis del JSON de las llamadas a herramientas use un analizador JSON estándar.
* Pasa de `client.beta.messages.create()` (csharp: `client.Beta.Messages.Create()`; go: `client.Beta.Messages.New()`; java: `client.beta().messages().create()`; php: `$client->beta->messages->create()`; cli: `ant beta:messages create`) a `client.messages.create()` (csharp: `client.Messages.Create()`; go: `client.Messages.New()`; java: `client.messages().create()`; php: `$client->messages->create()`; cli: `ant messages create`): el pensamiento adaptativo y el esfuerzo no necesitan un espacio de nombres beta.
* Elimina el encabezado beta `effort-2025-11-24` (el parámetro effort no lo requiere).
* Elimina el encabezado beta `fine-grained-tool-streaming-2025-05-14`.
* Elimina el encabezado beta `interleaved-thinking-2025-05-14` (el pensamiento adaptativo habilita automáticamente el pensamiento intercalado).
* Migra `output_format` a `output_config.format` (si corresponde).
### Claude 4.1 o anterior
* Actualiza las versiones de las herramientas (`text_editor_20250728`, `code_execution_20260521`).
* Gestiona el motivo de detención `refusal`.
* Gestiona el motivo de detención `model_context_window_exceeded`.
* Verifica el manejo de los parámetros de cadena de las herramientas en cuanto a saltos de línea finales.
* Elimina los encabezados beta heredados (`token-efficient-tools-2025-02-19`, `output-128k-2025-02-19`).
* Revisa y actualiza los prompts siguiendo las [mejores prácticas de prompting](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/claude-prompting-best-practices).
### Solo Claude Sonnet 5
* Si reconstruyes el historial de la conversación para actualizar instrucciones, considera cambiar a un mensaje del sistema a mitad de la conversación para preservar los aciertos de la caché de prompts.
* Revisa los prompts cercanos al mínimo de caché: los prompts de 512 tokens o más pueden crear entradas de caché.
## Migración a Claude Opus 5.5 desde Claude Opus 5
Primero revisa [Lo que debe cumplir cada solicitud a Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#request-requirements) y [Gestiona el pensamiento en cada respuesta](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-in-every-response). Todos los modelos de partida necesitan los cambios de esta sección. Son las configuraciones de solicitud que Claude Opus 5.5 rechaza y los cambios en las respuestas que lo acompañan. La lista de verificación de esta sección es el primer grupo de la [lista de verificación de migración](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migration-checklist).
### Actualiza el nombre de tu modelo
```python
model = "claude-opus-5" # Before
model = "claude-opus-5-5" # After
```
`claude-opus-5-5` es un ID de modelo fijo sin sufijo de fecha, el mismo esquema que `claude-opus-5`. En Amazon Bedrock, Claude Platform on AWS, Google Cloud y Microsoft Foundry, usa el ID de modelo de esa plataforma; consulta [Disponibilidad](https://platform.claude.com/docs/es/models/opus-5-5/whats-new-opus-5-5#availability).
### Cambios incompatibles
Cada cambio se explica en [Novedades de Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/whats-new-opus-5-5#breaking-changes); esta sección muestra el cambio de código para cada uno.
#### El pensamiento no se puede desactivar
Tanto `thinking: {"type": "disabled"}` como `thinking: {"type": "enabled", "budget_tokens": N}` devuelven un error 400 (`"thinking.type.disabled" is not supported for this model.` o `"thinking.type.enabled" is not supported for this model.`). Elimina el campo `thinking` y elige un nivel de [esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort); donde desactivabas el pensamiento para ahorrar tokens, usa uno más bajo. Las respuestas comienzan entonces con bloques `thinking`, así que selecciona los bloques de contenido por `type` y devuelve los bloques `thinking` sin modificar junto con los resultados de las herramientas. Consulta [El pensamiento no se puede desactivar](https://platform.claude.com/docs/es/models/opus-5-5/whats-new-opus-5-5#thinking-cant-be-disabled).
Antes. Claude Opus 5 acepta esta solicitud, y Claude Opus 5.5 la rechaza con un error 400:
```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",
"max_tokens": 16000,
"thinking": {"type": "disabled"},
"messages": [{"role": "user", "content": "..."}]
}'
```
```bash CLI
ant messages create \
--model claude-opus-5 \
--max-tokens 16000 \
--thinking '{type: disabled}' \
--message '{role: user, content: "..."}'
```
```python Python
client.messages.create(
model="claude-opus-5",
max_tokens=16000,
thinking={"type": "disabled"},
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5",
max_tokens: 16000,
thinking: { type: "disabled" },
messages: [{ role: "user", content: "..." }]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5,
MaxTokens = 16000,
Thinking = new ThinkingConfigDisabled(),
Messages = [new() { Role = Role.User, Content = "..." }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5,
MaxTokens: 16000,
Thinking: anthropic.ThinkingConfigParamUnion{
OfDisabled: &anthropic.ThinkingConfigDisabledParam{},
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5)
.maxTokens(16000L)
.thinking(ThinkingConfigDisabled.builder().build())
.addUserMessage("...")
.build();
client.messages().create(params);
```
```php PHP
$client->messages->create(
model: Model::CLAUDE_OPUS_5,
maxTokens: 16000,
thinking: ThinkingConfigDisabled::with(),
messages: [['role' => 'user', 'content' => '...']],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5,
max_tokens: 16000,
thinking: Anthropic::ThinkingConfigDisabled.new,
messages: [{ role: "user", content: "..." }]
)
```
Después:
```bash cURL
# el pensamiento (thinking) siempre está activo; effort es lo que lo controla
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": 16000,
"output_config": {"effort": "low"},
"messages": [{"role": "user", "content": "..."}]
}'
```
```bash CLI
# el pensamiento (thinking) siempre está activo; effort es lo que lo controla
ant messages create \
--model claude-opus-5-5 \
--max-tokens 16000 \
--output-config '{effort: low}' \
--message '{role: user, content: "..."}'
```
```python Python
client.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
output_config={"effort": "low"}, # thinking is always on; effort is the control
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
output_config: { effort: "low" }, // thinking is always on; effort is the control
messages: [{ role: "user", content: "..." }]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
OutputConfig = new() { Effort = Effort.Low }, // thinking is always on; effort is the control
Messages = [new() { Role = Role.User, Content = "..." }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
OutputConfig: anthropic.OutputConfigParam{
Effort: anthropic.OutputConfigEffortLow, // thinking is always on; effort is the control
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
// el pensamiento (thinking) siempre está activo; se controla con effort (esfuerzo)
.outputConfig(OutputConfig.builder()
.effort(OutputConfig.Effort.LOW)
.build())
.addUserMessage("...")
.build();
client.messages().create(params);
```
```php PHP
$client->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 16000,
// el pensamiento siempre está activo; effort es lo que lo controla
outputConfig: OutputConfig::with(effort: Effort::LOW),
messages: [['role' => 'user', 'content' => '...']],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 16000,
# thinking siempre está activo; effort es lo que lo controla
output_config: { effort: Anthropic::OutputConfig::Effort::LOW },
messages: [{ role: "user", content: "..." }]
)
```
#### El uso forzado de herramientas no es compatible
Los tipos de `tool_choice` `any` y `tool` devuelven un error 400 (`tool_choice: type "tool" and "any" are not supported for this model.`), incluso en el endpoint de conteo de tokens. Usa `auto` con [uso estricto de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/strict-tool-use) o [salidas estructuradas](https://platform.claude.com/docs/es/build-with-claude/structured-outputs), e indica en el prompt cuándo se aplica la herramienta. El uso estricto de herramientas acepta un subconjunto de JSON Schema, así que revisa el `input_schema` de cada herramienta antes de agregar `strict: true`. Cada objeto del esquema debe establecer `additionalProperties: false`; consulta [Limitaciones de JSON Schema](https://platform.claude.com/docs/es/build-with-claude/structured-outputs#json-schema-limitations). En Amazon Bedrock, las salidas estructuradas, que incluyen el uso estricto de herramientas, no están disponibles para Claude Opus 5.5. Allí, envía `auto` sin `strict`, indica en el prompt cuándo se aplica la herramienta y valida la entrada de la herramienta en tu código. Consulta [El uso forzado de herramientas no es compatible](https://platform.claude.com/docs/es/models/opus-5-5/whats-new-opus-5-5#forced-tool-use-is-not-supported).
Antes. Claude Opus 5 acepta esta solicitud, y Claude Opus 5.5 la rechaza con un error 400:
```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",
"max_tokens": 1024,
"tools": [{
"name": "get_weather",
"description": "Get the current weather in a given location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA"
}
},
"required": ["location"],
"additionalProperties": false
}
}],
"tool_choice": {"type": "tool", "name": "get_weather"},
"messages": [{"role": "user", "content": "What'\''s the weather in Paris?"}]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-5
max_tokens: 1024
tools:
- name: get_weather
description: Get the current weather in a given location
input_schema:
type: object
properties:
location:
type: string
description: The city and state, e.g. San Francisco, CA
required: [location]
additionalProperties: false
tool_choice:
type: tool
name: get_weather
messages:
- role: user
content: What's the weather in Paris?
YAML
```
```python Python
client.messages.create(
model="claude-opus-5",
max_tokens=1024,
tools=tools,
tool_choice={"type": "tool", "name": "get_weather"},
messages=[{"role": "user", "content": "What's the weather in Paris?"}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5",
max_tokens: 1024,
tools,
tool_choice: { type: "tool", name: "get_weather" },
messages: [{ role: "user", content: "What's the weather in Paris?" }]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5,
MaxTokens = 1024,
Tools = [.. tools],
ToolChoice = new ToolChoiceTool { Name = "get_weather" },
Messages = [new() { Role = Role.User, Content = "What's the weather in Paris?" }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5,
MaxTokens: 1024,
Tools: tools,
ToolChoice: anthropic.ToolChoiceParamOfTool("get_weather"),
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("What's the weather in Paris?")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5)
.maxTokens(1024L)
.tools(tools)
.toolChoice(ToolChoiceTool.of("get_weather"))
.addUserMessage("What's the weather in Paris?")
.build();
client.messages().create(params);
```
```php PHP
$client->messages->create(
model: Model::CLAUDE_OPUS_5,
maxTokens: 1024,
tools: $tools,
toolChoice: ToolChoiceTool::with(name: 'get_weather'),
messages: [['role' => 'user', 'content' => "What's the weather in Paris?"]],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5,
max_tokens: 1024,
tools: tools,
tool_choice: Anthropic::ToolChoiceTool.new(name: "get_weather"),
messages: [{ role: "user", content: "What's the weather in Paris?" }]
)
```
Después:
```bash cURL
# uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
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": 1024,
"tools": [{
"name": "get_weather",
"description": "Get the current weather in a given location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA"
}
},
"required": ["location"],
"additionalProperties": false
},
"strict": true
}],
"tool_choice": {"type": "auto"},
"messages": [{
"role": "user",
"content": "What'\''s the weather in Paris? Use the get_weather tool."
}]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
tools:
- name: get_weather
description: Get the current weather in a given location
input_schema:
type: object
properties:
location:
type: string
description: The city and state, e.g. San Francisco, CA
required: [location]
additionalProperties: false
# uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
strict: true
tool_choice:
type: auto
messages:
- role: user
content: What's the weather in Paris? Use the get_weather tool.
YAML
```
```python Python
client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
# uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
tools=[{**tool, "strict": True} for tool in tools],
tool_choice={"type": "auto"},
messages=[
{
"role": "user",
"content": "What's the weather in Paris? Use the get_weather tool.",
}
],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 1024,
// uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
tools: tools.map((tool) => ({ ...tool, strict: true })),
tool_choice: { type: "auto" },
messages: [
{
role: "user",
content: "What's the weather in Paris? Use the get_weather tool."
}
]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 1024,
// uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
Tools = [.. tools.Select(tool => tool with { Strict = true })],
ToolChoice = new ToolChoiceAuto(),
Messages =
[
new()
{
Role = Role.User,
Content = "What's the weather in Paris? Use the get_weather tool.",
},
],
});
```
```go Go
// uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
var strictTools []anthropic.ToolUnionParam
for _, tool := range tools {
strictTool := *tool.OfTool
strictTool.Strict = anthropic.Bool(true)
strictTools = append(strictTools, anthropic.ToolUnionParam{OfTool: &strictTool})
}
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 1024,
Tools: strictTools,
ToolChoice: anthropic.ToolChoiceUnionParam{OfAuto: &anthropic.ToolChoiceAutoParam{}},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(
anthropic.NewTextBlock("What's the weather in Paris? Use the get_weather tool."),
),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(1024L)
// uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
.tools(tools.stream()
.map(tool -> tool.tool()
.map(customTool -> customTool.toBuilder().strict(true).build())
.map(ToolUnion::ofTool)
.orElse(tool))
.toList())
.toolChoice(ToolChoiceAuto.builder().build())
.addUserMessage("What's the weather in Paris? Use the get_weather tool.")
.build();
client.messages().create(params);
```
```php PHP
$client->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 1024,
// uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
tools: array_map(fn (Tool $tool) => $tool->withStrict(true), $tools),
toolChoice: ToolChoiceAuto::with(),
messages: [
[
'role' => 'user',
'content' => "What's the weather in Paris? Use the get_weather tool.",
],
],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 1024,
# uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
tools: tools.map { |tool| tool.merge(strict: true) },
tool_choice: Anthropic::ToolChoiceAuto.new,
messages: [
{ role: "user", content: "What's the weather in Paris? Use the get_weather tool." }
]
)
```
#### Los bloques de pensamiento están vinculados al modelo y a la conversación
En la Claude API, Claude Fable 5.1 y Claude Mythos 5.1 leen los bloques de pensamiento de Claude Opus 5.5; ningún otro modelo lo hace. Un enrutador o un fallback que mueve una conversación de Claude Opus 5.5 a cualquier otro modelo ejecuta esos turnos sin ellos. En la otra dirección, Claude Opus 5.5 lee los bloques de pensamiento de Claude Opus 5, de modelos Opus, Sonnet y Haiku anteriores y, en la Claude API y Google Cloud, de Claude Sonnet 5.5 y Claude Haiku 5.5, pero no de los modelos Claude Fable ni Claude Mythos. Mantén la conversación en modo de solo anexar (sin ediciones a la indicación `system`, a `tools` ni a mensajes anteriores a mitad de la conversación) para que los bloques sigan siendo válidos; Claude Code, claude.ai, Claude Managed Agents y el Claude Agent SDK ya lo hacen. La aplicación de esta regla coincide con Claude Fable 5.1 en todas las plataformas: para las cuentas creadas a partir del 31 de agosto de 2026, 00:00 UTC, reenviar un bloque de pensamiento después de una edición así devuelve un error 400 de forma predeterminada. No hay cambio de código para las integraciones de solo anexar. Consulta [Los bloques de pensamiento están vinculados al modelo y a la conversación](https://platform.claude.com/docs/es/models/opus-5-5/whats-new-opus-5-5#thinking-blocks-are-tied-to-the-model-that-produced-them) y [Pensamiento preservado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking).
#### La herramienta de uso de computadora `computer_20251124` no es compatible en la Claude API ni en Google Cloud
En la Claude API y Google Cloud, una entrada de `tools` de tipo `computer_20251124` devuelve un error 400 (`'claude-opus-5-5' does not support tool types: computer_20251124.`, seguido de los tipos de herramienta que acepta el modelo). Declara en su lugar el conjunto de herramientas `computer_toolset_20260801`: elimina el encabezado beta y envía la entrada sin `name` ni dimensiones de pantalla. En tu bucle de agente, gestiona los bloques `tool_use` de los miembros (la acción es el `name` del bloque, no `input.action`), varios de ellos por turno, y reenvía `toolset_name` en cada resultado. El cambio en la solicitud se muestra a continuación; los cambios en el bucle de agente se enumeran en [Migrar desde `computer_20251124`](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124). En Amazon Bedrock, la herramienta anterior `computer_20251124` sigue funcionando en Claude Opus 5.5 igual que en Claude Opus 5, por lo que no se necesita ningún cambio allí; para otras plataformas, consulta la sección [Compatibilidad](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool#compatibility) de la herramienta de uso de computadora. Consulta [La herramienta de uso de computadora `computer_20251124` no es compatible en la Claude API ni en Google Cloud](https://platform.claude.com/docs/es/models/opus-5-5/whats-new-opus-5-5#computer-20251124-is-not-supported).
Antes. Claude Opus 5 acepta esta solicitud, y en la Claude API y Google Cloud, Claude Opus 5.5 la rechaza con un error 400:
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: computer-use-2025-11-24" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5",
"max_tokens": 4096,
"tools": [{
"type": "computer_20251124",
"name": "computer",
"display_width_px": 1024,
"display_height_px": 768
}],
"messages": [{"role": "user", "content": "Open the display settings."}]
}'
```
```bash CLI
ant beta:messages create \
--model claude-opus-5 \
--max-tokens 4096 \
--beta computer-use-2025-11-24 \
--tool '{
type: computer_20251124,
name: computer,
display_width_px: 1024,
display_height_px: 768
}' \
--message '{role: user, content: "Open the display settings."}'
```
```python Python
client.beta.messages.create(
model="claude-opus-5",
max_tokens=4096,
betas=["computer-use-2025-11-24"],
tools=[
{
"type": "computer_20251124",
"name": "computer",
"display_width_px": 1024,
"display_height_px": 768,
}
],
messages=[{"role": "user", "content": "Open the display settings."}],
)
```
```typescript TypeScript
await client.beta.messages.create({
model: "claude-opus-5",
max_tokens: 4096,
betas: ["computer-use-2025-11-24"],
tools: [
{
type: "computer_20251124",
name: "computer",
display_width_px: 1024,
display_height_px: 768
}
],
messages: [{ role: "user", content: "Open the display settings." }]
});
```
```csharp C#
await client.Beta.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5,
MaxTokens = 4096,
Betas = [AnthropicBeta.ComputerUse2025_11_24],
Tools =
[
new BetaToolComputerUse20251124
{
DisplayWidthPx = 1024,
DisplayHeightPx = 768,
},
],
Messages = [new() { Role = Role.User, Content = "Open the display settings." }],
});
```
```go Go
client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5,
MaxTokens: 4096,
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaComputerUse2025_11_24},
Tools: []anthropic.BetaToolUnionParam{
{OfComputerUseTool20251124: &anthropic.BetaToolComputerUse20251124Param{
DisplayWidthPx: 1024,
DisplayHeightPx: 768,
}},
},
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Open the display settings.")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5)
.maxTokens(4096L)
.addBeta(AnthropicBeta.COMPUTER_USE_2025_11_24)
.addTool(BetaToolComputerUse20251124.builder()
.displayWidthPx(1024L)
.displayHeightPx(768L)
.build())
.addUserMessage("Open the display settings.")
.build();
client.beta().messages().create(params);
```
```php PHP
$client->beta->messages->create(
model: Model::CLAUDE_OPUS_5,
maxTokens: 4096,
betas: [AnthropicBeta::COMPUTER_USE_2025_11_24],
tools: [
BetaToolComputerUse20251124::with(
displayWidthPx: 1024,
displayHeightPx: 768,
),
],
messages: [['role' => 'user', 'content' => 'Open the display settings.']],
);
```
```ruby Ruby
client.beta.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5,
max_tokens: 4096,
betas: [Anthropic::AnthropicBeta::COMPUTER_USE_2025_11_24],
tools: [
Anthropic::Beta::BetaToolComputerUse20251124.new(
name: :computer,
display_width_px: 1024,
display_height_px: 768
)
],
messages: [{ role: "user", content: "Open the display settings." }]
)
```
Después:
```bash cURL
# sin encabezado beta; la entrada del toolset no lleva nombre ni tamaño de pantalla
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,
"tools": [{"type": "computer_toolset_20260801"}],
"messages": [{"role": "user", "content": "Open the display settings."}]
}'
```
```bash CLI
# sin encabezado beta; la entrada del toolset no lleva nombre ni tamaño de pantalla
ant messages create \
--model claude-opus-5-5 \
--max-tokens 4096 \
--tool '{type: computer_toolset_20260801}' \
--message '{role: user, content: "Open the display settings."}'
```
```python Python
client.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
# sin encabezado beta; la entrada del toolset no lleva nombre ni tamaño de pantalla
tools=[{"type": "computer_toolset_20260801"}],
messages=[{"role": "user", "content": "Open the display settings."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
// sin encabezado beta; la entrada del conjunto de herramientas no lleva nombre ni tamaño de pantalla
tools: [{ type: "computer_toolset_20260801" }],
messages: [{ role: "user", content: "Open the display settings." }]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
// sin encabezado beta; la entrada del conjunto de herramientas no lleva nombre ni tamaño de pantalla
Tools = [new ComputerToolset20260801()],
Messages = [new() { Role = Role.User, Content = "Open the display settings." }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
// sin encabezado beta; la entrada del conjunto de herramientas no lleva nombre ni tamaño de pantalla
Tools: []anthropic.ToolUnionParam{
{OfComputerToolset20260801: &anthropic.ComputerToolset20260801Param{}},
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Open the display settings.")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
// sin encabezado beta; la entrada del conjunto de herramientas no lleva nombre ni tamaño de pantalla
.addTool(ComputerToolset20260801.builder().build())
.addUserMessage("Open the display settings.")
.build();
client.messages().create(params);
```
```php PHP
$client->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 4096,
// sin encabezado beta; la entrada del conjunto de herramientas no lleva nombre ni tamaño de pantalla
tools: [ComputerToolset20260801::with()],
messages: [['role' => 'user', 'content' => 'Open the display settings.']],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
# sin encabezado beta; la entrada del toolset no lleva nombre ni tamaño de pantalla
tools: [Anthropic::ComputerToolset20260801.new],
messages: [{ role: "user", content: "Open the display settings." }]
)
```
### El texto entre llamadas a herramientas se devuelve en bloques de pensamiento
En Claude Opus 5, el texto que el modelo escribe entre llamadas a herramientas se devuelve como bloques `text`. En Claude Opus 5.5, al igual que en Claude Fable 5.1, esa narración se devuelve como [bloques `thinking` de actualización de progreso](https://platform.claude.com/docs/es/build-with-claude/thinking#progress-updates), con un máximo de uno antes de cada llamada a herramienta. Con el valor predeterminado de `thinking.display`, que es `"omitted"`, su campo `thinking` está vacío. Ninguna solicitud falla, pero una aplicación que hace streaming de ese texto a sus usuarios como actualizaciones de progreso se queda en silencio entre llamadas a herramientas.
Para restaurar las actualizaciones, léelas de los bloques `thinking` y establece un valor de `display` que devuelva su texto:
* `"updates"` (beta, encabezado `thinking-display-updates-2026-08-18`) devuelve las actualizaciones de progreso y mantiene oculto el razonamiento.
* `"summarized"` devuelve ambos, mezclados.
Luego, muestra cada bloque `thinking` no vacío antes del bloque `tool_use` al que precede, y devuelve los bloques sin cambios junto con el resto del turno del asistente. Consulta [Actualizaciones de progreso para el usuario](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates).
### Clasificadores de seguridad y fallback
Claude Opus 5.5 puede devolver `stop_reason: "refusal"` con una categoría en `stop_details`. Sus clasificadores cubren un conjunto de categorías más amplio que los de Claude Opus 5, así que espera valores de `stop_details.category` como `"bio"` además de `"cyber"` y `"reasoning_extraction"`; consulta la [tabla de categorías de rechazo](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#refusal-response). Gestiona los rechazos y configura el [fallback del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#server-side-fallback) o tu propio reintento (el fallback del lado del servidor no reintenta las solicitudes rechazadas con `"reasoning_extraction"`; ese rechazo se te devuelve); consulta [Rechazos y fallback](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback) y [Rechazos de salvaguardas](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#safeguard-refusals).
### Cambios recomendados
1. **Vuelve a ejecutar tu barrido de esfuerzo.** El esfuerzo es el único control del pensamiento en Claude Opus 5.5, y su valor predeterminado es `medium`, mientras que el de Claude Opus 5 es `high`, por lo que una solicitud que omite `effort` ahora se ejecuta en `medium`. Baja el nivel donde la calidad se mantenga y súbelo para el trabajo más exigente. Consulta [Esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort).
2. **Vuelve a evaluar las instrucciones de prompt específicas del modelo.** Es posible que las instrucciones ajustadas al comportamiento de Claude Opus 5 ya no sean necesarias; 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). Si ejecutabas con el pensamiento desactivado, consulta también [Prompts escritos para el pensamiento desactivado](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#prompts-written-for-thinking-disabled).
3. **Prueba en un entorno de desarrollo** antes de cambiar el tráfico de producción.
## Migración a Claude Opus 5.5 desde Claude Opus 4.8
Primero revisa [Lo que debe cumplir cada solicitud a Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#request-requirements), [Gestiona el pensamiento en cada respuesta](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-in-every-response) y [Migración a Claude Opus 5.5 desde Claude Opus 5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-5). Usa `claude-opus-4-8` como el ID de modelo que reemplazas. Esa última sección se aplica tal cual al código en Claude Opus 4.8, porque Claude Opus 4.8, al igual que Claude Opus 5:
* Acepta `thinking: {"type": "disabled"}`, la elección forzada de herramienta y la herramienta `computer_20251124`.
* Devuelve el texto entre llamadas a herramientas como bloques `text`.
* Usa el esfuerzo `high` de forma predeterminada.
Esta sección agrega lo que cambió entre Claude Opus 4.8 y Claude Opus 5. Para una lista de verificación, consulta los dos primeros grupos de la [lista de verificación de migración](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migration-checklist).
### Qué cambió
1. **El pensamiento se ejecuta en las solicitudes que lo omitían:** En Claude Opus 4.8, el pensamiento está desactivado a menos que lo solicites. En Claude Opus 5.5, una solicitud sin campo `thinking` se ejecuta con pensamiento, por lo que cada elemento de [Gestiona el pensamiento en cada respuesta](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-in-every-response) es un cambio para ese código. Si tu código nunca envió un campo `thinking`, no hay nada que eliminar según el [antes y después para el pensamiento](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-cant-be-disabled).
2. **Mínimo más bajo para el almacenamiento en caché de prompts:** La longitud mínima de prompt almacenable en caché en Claude Opus 5.5 es de 512 tokens, frente a 1,024 tokens en Claude Opus 4.8. Los prompts que eran demasiado cortos para almacenarse en caché en Claude Opus 4.8 pueden crear entradas de caché, sin necesidad de cambios de código. Consulta [Almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching#cache-limitations) para conocer los mínimos por modelo.
3. **Priority Tier no es compatible:** [Priority Tier](https://platform.claude.com/docs/es/api/service-tiers#supported-models) no es compatible con Claude Opus 5.5, mientras que Claude Opus 4.8 lo mantiene. Si tu organización tiene un compromiso de Priority Tier, planifica la capacidad por separado.
### Cambios recomendados
No son obligatorios, pero mejorarán tu experiencia:
1. **Considera los presupuestos de tareas (beta):** En cargas de trabajo agénticas, los [presupuestos de tareas](https://platform.claude.com/docs/es/build-with-claude/task-budgets) le indican al modelo cuántos tokens tiene disponibles para un bucle agéntico completo. Requieren el encabezado beta `task-budgets-2026-03-13`.
2. **Considera los cambios de herramientas a mitad de la conversación (beta):** Los cambios de herramientas a mitad de la conversación te permiten agregar o quitar herramientas entre turnos de una conversación sin invalidar los aciertos de la [caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching) en los turnos anteriores. Modificar directamente el arreglo `tools` invalida el prefijo almacenado en caché. En la Claude API, envía el encabezado beta `inline-tools-2026-09-15`. El encabezado anterior `mid-conversation-tool-changes-2026-07-01` sigue funcionando para los cambios que hacen referencia a una herramienta por su nombre, en la Claude API, Amazon Bedrock y Google Cloud.
## Migración a Claude Opus 5.5 desde Claude Opus 4.7
Primero revisa [Lo que debe cumplir cada solicitud a Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#request-requirements), [Gestiona el pensamiento en cada respuesta](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-in-every-response), [Migración a Claude Opus 5.5 desde Claude Opus 5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-5) y [Migración a Claude Opus 5.5 desde Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8). Usa `claude-opus-4-7` como el ID de modelo que reemplazas. Esas secciones se aplican tal cual al código en Claude Opus 4.7. Al igual que Claude Opus 4.8, acepta `thinking: {"type": "disabled"}`, la elección forzada de herramienta y la herramienta `computer_20251124`. Usa el esfuerzo `high` de forma predeterminada y se ejecuta sin pensamiento a menos que lo solicites.
Esta sección agrega lo que cambió después de Claude Opus 4.7. Si tu código está en Claude Opus 4.6 o anterior, continúa con [Migración a Claude Opus 5.5 desde Claude Opus 4.6 y modelos Opus anteriores](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-46) después de esta sección. Esa sección agrega los cambios incompatibles que entraron en vigor en Claude Opus 4.7. Para una lista de verificación, consulta los tres primeros grupos de la [lista de verificación de migración](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migration-checklist).
### Qué cambió
Ninguno de estos elementos agrega un cambio incompatible a los de las secciones anteriores; vale la pena revisarlos después de cambiar el ID del modelo.
1. **Niveles de esfuerzo recalibrados:** La asignación de tokens detrás de cada nivel de esfuerzo cambia en Claude Opus 5.5 en comparación con Claude Opus 4.7. El valor predeterminado es `medium`, mientras que el de Claude Opus 4.7 es `high`. Ejecuta un nuevo barrido de esfuerzo con tus propias evaluaciones en lugar de trasladar una configuración ajustada para Claude Opus 4.7. Consulta [Esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort).
2. **La ventana de contexto de 1M es la predeterminada:** Claude Opus 5.5 ofrece la [ventana de contexto](https://platform.claude.com/docs/es/build-with-claude/context-windows) completa de 1M de tokens de forma predeterminada, sin encabezado beta. Si tu cliente envía un encabezado beta de ventana de contexto por compatibilidad con modelos anteriores, elimínalo.
3. **Mensajes del sistema a mitad de la conversación:** En la Claude API, Amazon Bedrock y Google Cloud, Claude Opus 5.5 acepta mensajes `role: "system"` inmediatamente después de un turno de usuario en el arreglo `messages` (sujeto a las [reglas de ubicación](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages#limitations)). Usa el campo `system` de nivel superior para las instrucciones que se aplican desde el inicio. Claude Opus 4.7 rechaza `role: "system"` en `messages` con un error 400. Si mantienes rutas de código que reconstruyen el historial completo de mensajes para actualizar instrucciones, puedes simplificarlas y preservar los aciertos de la [caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching) en turnos anteriores.
4. **Detalles de detención por rechazo:** Cuando el modelo rechaza una solicitud, Claude Opus 5.5 devuelve un objeto `stop_details` que nombra la categoría del rechazo, junto con el motivo de detención `refusal`. Claude Opus 4.7 devuelve el mismo objeto, así que esto solo importa si tu manejo de motivos de detención aún no lo lee. No se requiere ningún encabezado beta y no hay forma de desactivarlo. Si tu manejo de motivos de detención aún no lo lee, consulta [Gestionar los motivos de detención](https://platform.claude.com/docs/es/build-with-claude/handling-stop-reasons). Claude Opus 5.5 rechaza en más categorías; consulta [Clasificadores de seguridad y fallback](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#safety-classifiers-and-fallback).
5. **Modo rápido:** Claude Opus 5.5 admite el [modo rápido](https://platform.claude.com/docs/es/build-with-claude/fast-mode) en la Claude API. El modo rápido no está disponible en Claude Opus 4.7, donde las solicitudes con `speed: "fast"` devuelven un error. Establece `speed: "fast"` en tus solicitudes. Claude Opus 5.5 no necesita un encabezado beta.
6. **Conjunto de herramientas de uso de computadora y herramienta de uso del navegador:** En la Claude API y Google Cloud, Claude Opus 5.5 admite el [uso de computadora](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool) como el conjunto de herramientas `computer_toolset_20260801` y la [herramienta de uso del navegador](https://platform.claude.com/docs/es/agents-and-tools/tool-use/browser-use-tool) para tareas dentro de páginas web. Claude Opus 4.7 no admite ninguno de los dos. En esas plataformas, Claude Opus 5.5 no acepta la herramienta anterior `computer_20251124`; consulta el [cambio incompatible del uso de computadora](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#computer-use-toolset).
## Migración a Claude Opus 5.5 desde Claude Opus 4.6 y modelos Opus anteriores
Primero revisa todas las secciones anteriores, en el orden de la página. Son [Lo que debe cumplir cada solicitud a Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#request-requirements), [Gestiona el pensamiento en cada respuesta](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-in-every-response) y las secciones de [Claude Opus 5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-5), [Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8) y [Claude Opus 4.7](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-47). Esas secciones se aplican tal cual al código en Claude Opus 4.6. Al igual que Claude Opus 4.7, acepta `thinking: {"type": "disabled"}`, la elección forzada de herramienta y la herramienta `computer_20251124`. Usa el esfuerzo `high` de forma predeterminada y se ejecuta sin pensamiento a menos que lo solicites. Claude Opus 4.5 y los modelos Opus anteriores también aceptan `thinking: {"type": "disabled"}` y la elección forzada de herramienta, y se ejecutan sin pensamiento a menos que lo solicites, por lo que esas secciones también se aplican a ellos.
Esta sección agrega lo que cambió en Claude Opus 4.7, con `claude-opus-4-6` como el ID de modelo que reemplazas. Sus dos subsecciones agregan lo que cambió antes de eso, para los lectores en [Claude Opus 4.5 o anterior](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-45) y [Claude 4.1 o anterior](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-4-1-or-earlier). Para una lista de verificación, consulta la [lista de verificación de migración](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migration-checklist) hasta el grupo que nombra tu modelo.
### Cambios incompatibles
1. **Pensamiento extendido eliminado:** `thinking: {"type": "enabled", "budget_tokens": N}` ya no es compatible con Claude Opus 4.7 y modelos posteriores, y devuelve un error 400. Cambia a [pensamiento adaptativo](https://platform.claude.com/docs/es/build-with-claude/thinking) (`thinking: {"type": "adaptive"}`) y usa el [parámetro effort](https://platform.claude.com/docs/es/build-with-claude/effort) para controlar la profundidad del pensamiento. En Claude Opus 5.5, el pensamiento adaptativo siempre está activado: `thinking: {"type": "adaptive"}` es válido y equivale a omitir por completo el campo `thinking`.
Antes (Claude Opus 4.6):
```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-4-6",
"max_tokens": 16000,
"thinking": {
"type": "enabled",
"budget_tokens": 10000
},
"messages": [
{
"role": "user",
"content": "..."
}
]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-4-6
max_tokens: 16000
thinking:
type: enabled
budget_tokens: 10000
messages:
- role: user
content: "..."
YAML
```
```python Python
client.messages.create(
model="claude-opus-4-6",
max_tokens=16000,
thinking={"type": "enabled", "budget_tokens": 10000},
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-4-6",
max_tokens: 16000,
thinking: { type: "enabled", budget_tokens: 10000 },
messages: [{ role: "user", content: "..." }]
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus4_6,
MaxTokens = 16000,
Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
Messages = [new() { Role = Role.User, Content = "..." }]
};
var response = await client.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus4_6,
MaxTokens: 16000,
Thinking: anthropic.ThinkingConfigParamOfEnabled(10000),
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_4_6)
.maxTokens(16000L)
.enabledThinking(10000L)
.addUserMessage("...")
.build();
Message response = client.messages().create(params);
IO.println(response);
```
```php PHP
$client = new Client();
$message = $client->messages->create(
maxTokens: 16000,
messages: [['role' => 'user', 'content' => '...']],
model: 'claude-opus-4-6',
thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
);
```
```ruby Ruby
client = Anthropic::Client.new
message = client.messages.create(
model: "claude-opus-4-6",
max_tokens: 16000,
thinking: {
type: "enabled",
budget_tokens: 10000
},
messages: [
{ role: "user", content: "..." }
]
)
```
Después (Claude Opus 5.5), donde difieren el ID del modelo y las líneas `thinking` y `output_config`:
```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": 16000,
"thinking": {
"type": "adaptive"
},
"output_config": {
"effort": "high"
},
"messages": [
{
"role": "user",
"content": "..."
}
]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
thinking:
type: adaptive
output_config:
effort: high
messages:
- role: user
content: "..."
YAML
```
```python Python
client.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
thinking={"type": "adaptive"},
output_config={"effort": "high"}, # or "max", "xhigh", "medium", "low"
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: { type: "adaptive" },
output_config: { effort: "high" }, // or "max", "xhigh", "medium", "low"
messages: [{ role: "user", content: "..." }]
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
Thinking = new ThinkingConfigAdaptive(),
OutputConfig = new OutputConfig { Effort = Effort.High }, // or Max, Xhigh, Medium, Low
Messages = [new() { Role = Role.User, Content = "..." }]
};
var response = await client.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Thinking: anthropic.ThinkingConfigParamUnion{
OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
},
OutputConfig: anthropic.OutputConfigParam{
Effort: anthropic.OutputConfigEffortHigh, // or Max, Xhigh, Medium, Low
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.thinking(ThinkingConfigAdaptive.builder().build())
.outputConfig(OutputConfig.builder()
.effort(OutputConfig.Effort.HIGH) // or MAX, XHIGH, MEDIUM, LOW
.build())
.addUserMessage("...")
.build();
Message response = client.messages().create(params);
IO.println(response);
```
```php PHP
$client = new Client();
$message = $client->messages->create(
maxTokens: 16000,
messages: [['role' => 'user', 'content' => '...']],
model: 'claude-opus-5-5',
thinking: ['type' => 'adaptive'],
outputConfig: ['effort' => 'high'], // or 'max', 'xhigh', 'medium', 'low'
);
```
```ruby Ruby
client = Anthropic::Client.new
message = client.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: {
type: "adaptive"
},
output_config: {
effort: "high" # or "max", "xhigh", "medium", "low"
},
messages: [
{ role: "user", content: "..." }
]
)
```
El pensamiento adaptativo se puede orientar mediante prompts y el [parámetro effort](https://platform.claude.com/docs/es/build-with-claude/effort), que reemplaza al presupuesto de pensamiento como la forma de controlar cuánto razona el modelo. Ejecuta un barrido de esfuerzo en tus propias evaluaciones en lugar de traducir un valor de `budget_tokens`. La [tabla de niveles de esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort#effort-levels) describe cuándo usar cada nivel, y [Niveles de esfuerzo recomendados para Claude Opus 5.5](https://platform.claude.com/docs/es/build-with-claude/effort#recommended-effort-levels-for-claude-opus-5-5) cubre este modelo.
2. **Parámetros de muestreo eliminados:** Establecer `temperature`, `top_p` o `top_k` en cualquier valor distinto del predeterminado en Claude Opus 4.7 y modelos posteriores, incluido Claude Opus 5.5, devuelve un error 400. El SDK de Python (v1.0 y posteriores) no los define, y pasarlos genera un `TypeError`. La ruta de migración más segura es omitir por completo estos parámetros de las cargas útiles de las solicitudes. Los prompts son la forma recomendada de guiar el comportamiento del modelo en Claude Opus 5.5. Si usabas `temperature = 0` para obtener determinismo, ten en cuenta que nunca garantizó salidas idénticas en modelos anteriores.
3. **Contenido de pensamiento omitido de forma predeterminada:** Los bloques de pensamiento siguen apareciendo en el flujo de respuesta en Claude Opus 4.7 y modelos posteriores, pero su campo `thinking` está vacío a menos que lo habilites explícitamente. Este es un cambio silencioso respecto a Claude Opus 4.6, donde el comportamiento predeterminado era devolver texto de pensamiento resumido. Para restaurarlo, consulta el punto 4 de [Gestiona el pensamiento en cada respuesta](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-in-every-response).
4. **Conteo de tokens actualizado:** Claude Opus 4.7 introdujo un nuevo tokenizador, que también usan los modelos Opus posteriores, incluido Claude Opus 5.5. Contribuye a un mejor rendimiento en una amplia variedad de tareas, y puede usar aproximadamente entre 1x y 1.35x tokens al procesar texto en comparación con los modelos anteriores a Claude Opus 4.7 (hasta \~35% más, según el contenido).
[`/v1/messages/count_tokens`](https://platform.claude.com/docs/es/build-with-claude/token-counting) devuelve un número de tokens para Claude Opus 5.5 diferente del que devolvía para Claude Opus 4.6. La eficiencia de tokens puede variar según la forma de la carga de trabajo.
Actualiza tus parámetros `max_tokens` para dar margen adicional, incluidos los disparadores de compactación, y vuelve a probar cualquier ruta de código que estime tokens del lado del cliente o que asuma una proporción fija de tokens por carácter. Usa el [endpoint de conteo de tokens](https://platform.claude.com/docs/es/build-with-claude/token-counting) para verificarlo. Las intervenciones en los prompts, [`task_budget`](https://platform.claude.com/docs/es/build-with-claude/task-budgets) y [`effort`](https://platform.claude.com/docs/es/build-with-claude/effort) pueden ayudar a controlar los costos; estos controles pueden implicar una compensación en la inteligencia del modelo.
5. **Eliminación del prefill (ya vigente en Claude Opus 4.6):** Prellenar mensajes del asistente devuelve un error 400 en Claude Opus 4.6 y modelos Opus posteriores, incluido Claude Opus 5.5, por lo que esto solo es un cambio si vienes de Claude Opus 4.5 o anterior. Usa [salidas estructuradas](https://platform.claude.com/docs/es/build-with-claude/structured-outputs) o instrucciones en la indicación del sistema en su lugar. En Amazon Bedrock, las salidas estructuradas no están disponibles para Claude Opus 5.5, así que usa instrucciones en la indicación del sistema allí.
### Cambios de comportamiento
Claude Opus 4.7 introdujo diferencias de comportamiento respecto a Claude Opus 4.6 que no son cambios incompatibles de la API. Estas tres afectan al código o al andamiaje:
1. **Actualizaciones de progreso integradas en trazas agénticas:** Claude Opus 4.7 proporciona al usuario actualizaciones más regulares y de mayor calidad a lo largo de trazas agénticas largas. Si agregaste andamiaje para forzar mensajes de estado intermedios ("Después de cada 3 llamadas a herramientas, resume el progreso"), intenta eliminarlo. En Claude Opus 5.5, estas actualizaciones llegan en bloques `thinking`, que están vacíos con el valor predeterminado de `thinking.display`. Para recibirlas, consulta [El texto entre llamadas a herramientas se devuelve en bloques de pensamiento](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#text-between-tool-calls). Para ajustar su longitud y contenido, consulta [Actualizaciones de progreso para el usuario](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates).
2. **Salvaguardas de ciberseguridad en tiempo real:** Con estas salvaguardas, añadidas en Claude Opus 4.7, las solicitudes que involucran temas prohibidos o de alto riesgo pueden dar lugar a rechazos. Para trabajo de seguridad legítimo, como pruebas de penetración, investigación de vulnerabilidades o red-teaming, solicita acceso al [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) para pedir restricciones reducidas. La vía de solicitud depende de cómo accedas a Claude.
3. **Compatibilidad con imágenes de alta resolución:** Claude Opus 4.7 es el primer modelo de Claude compatible con imágenes de alta resolución. La resolución máxima de imagen es de 2,576 píxeles en el lado largo, frente a 1,568 píxeles en modelos anteriores. Esto permite mejoras en cargas de trabajo con mucho contenido visual y es especialmente valioso para el uso de computadora, la comprensión de capturas de pantalla y el análisis de documentos.
La compatibilidad con alta resolución es automática y no requiere ningún encabezado beta ni activación del lado del cliente. Hay dos aspectos que debes planificar:
* Las imágenes a resolución completa pueden usar hasta aproximadamente 3 veces más tokens de imagen que en modelos anteriores (hasta 4,784 tokens por imagen, en comparación con el límite anterior de aproximadamente 1,600 tokens por imagen). Vuelve a calcular el presupuesto de `max_tokens` y las expectativas de costo para cargas de trabajo con muchas imágenes, o reduce la resolución antes de enviarlas si no necesitas la fidelidad adicional.
* Las coordenadas de señalamiento y de cuadros delimitadores que devuelve el modelo corresponden 1:1 con los píxeles reales de la imagen en Claude Opus 4.7, por lo que no se requiere ninguna conversión de factor de escala.
Consulta [Compatibilidad con imágenes de alta resolución en Claude Opus 4.7](https://platform.claude.com/docs/es/build-with-claude/vision#high-resolution-image-support-on-claude-opus-4-7) para obtener más detalles.
Para las diferencias relacionadas con los 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) y [Mejores prácticas de prompting](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/claude-prompting-best-practices).
### Migrar desde Claude Opus 4.5 o anterior
Si estás migrando desde Claude Opus 4.5, Claude Opus 4.1 o un modelo anterior directamente a Claude Opus 5.5, lee esta página desde el principio: primero revisa cada una de las secciones anteriores, en el orden de la página. Luego revisa los [cambios incompatibles al migrar desde Claude Opus 4.6](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#opus-46-breaking-changes), que aparecen antes en esta sección. Después aplica los siguientes cambios acumulativos, que entraron en vigor entre Claude Opus 4.5 y Claude Opus 4.7. Si usas Claude Opus 4.1 o anterior, continúa con [Migrar desde Claude 4.1 o anterior](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-4-1-or-earlier) después de esta subsección.
#### Cambios incompatibles
1. La **eliminación del prefill** se trata en los [cambios incompatibles al migrar desde Claude Opus 4.6](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#opus-46-breaking-changes).
2. **Entrecomillado de parámetros de herramientas:** Claude Opus 4.6 y los modelos posteriores pueden producir un escape de cadenas JSON ligeramente diferente en los argumentos de las llamadas a herramientas (por ejemplo, un manejo diferente de los escapes Unicode o del escape de barras diagonales). Si analizas el `input` de las llamadas a herramientas como una cadena sin procesar en lugar de usar un analizador JSON, verifica tu lógica de análisis. Los analizadores JSON estándar (como `json.loads()` o `JSON.parse()`) manejan estas diferencias automáticamente.
#### Cambios recomendados
El primer punto es obligatorio en Claude Opus 5.5; el resto son recomendados.
1. **Migra al pensamiento adaptativo (obligatorio):** `thinking: {"type": "enabled", "budget_tokens": N}` devuelve un error 400 en Claude Opus 4.7 y modelos posteriores. El antes y el después se encuentran en el punto 1 de los [cambios incompatibles para migrar desde Claude Opus 4.6](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#opus-46-breaking-changes). La migración también pasa de `client.beta.messages.create()` (csharp: `client.Beta.Messages.Create()`; go: `client.Beta.Messages.New()`; java: `client.beta().messages().create()`; php: `$client->beta->messages->create()`; cli: `ant beta:messages create`) a `client.messages.create()` (csharp: `client.Messages.Create()`; go: `client.Messages.New()`; java: `client.messages().create()`; php: `$client->messages->create()`; cli: `ant messages create`): el pensamiento adaptativo y el esfuerzo no requieren el espacio de nombres beta del SDK ni ningún encabezado beta.
2. **Elimina el encabezado beta de effort:** El parámetro effort no requiere un encabezado beta. Elimina la beta `effort-2025-11-24` de tus solicitudes.
3. **Elimina el encabezado beta de streaming de herramientas detallado:** El streaming de herramientas detallado no requiere un encabezado beta. Elimina la beta `fine-grained-tool-streaming-2025-05-14` de tus solicitudes.
4. **Elimina el encabezado beta de pensamiento intercalado:** Con el pensamiento adaptativo, el pensamiento intercalado es automático en todos los modelos compatibles con el pensamiento adaptativo. Elimina la beta `interleaved-thinking-2025-05-14` de tus solicitudes.
5. **Migra a output\_config.format:** Si usas salidas estructuradas, actualiza `output_format={...}` a `output_config={"format": {...}}`. El parámetro `output_format` está obsoleto y se eliminará en el futuro. Para usarlo de todos modos, agrega el encabezado beta `structured-outputs-2025-11-13`. Sin él, la API devuelve un error 400. El SDK de Python (v1.0 y posteriores) no acepta `output_format={...}` en `client.beta.messages.create()` ni en `count_tokens()`. El argumento `output_format=Model` de los helpers `parse()` y `stream()` no cambia.
### Migrar desde Claude 4.1 o anterior
Si estás migrando desde Claude Opus 4.1 o modelos anteriores directamente a Claude Opus 5.5, primero aplica todo lo indicado en [Migrar desde Claude Opus 4.5 o anterior](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-45). Esa subsección comienza con todas las secciones anteriores, así que, en la práctica, lees esta página desde el principio. Luego aplica los cambios adicionales de esta subsección.
#### Cambios incompatibles adicionales
1. **Elimina los parámetros de muestreo:** Se trata en [Se eliminaron los parámetros de muestreo](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#opus-46-breaking-changes).
2. **Actualiza las versiones de las herramientas**
Este es un cambio incompatible al migrar desde modelos Claude 3.x.
Actualiza a las versiones actuales de las herramientas. Elimina cualquier código que use el comando `undo_edit`.
```python Python
# Antes
tools = [{"type": "text_editor_20250124", "name": "str_replace_editor"}]
# Después
tools = [{"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"}]
```
```typescript TypeScript
// Antes
const legacyTools = [{ type: "text_editor_20250124", name: "str_replace_editor" }];
// Después
const tools = [{ type: "text_editor_20250728", name: "str_replace_based_edit_tool" }];
```
```csharp C#
var parameters = new MessageCreateParams
{
// Antes: {"type": "text_editor_20250124", "name": "str_replace_editor"}
// Después:
Tools = [new ToolTextEditor20250728()],
// ...
};
```
```go Go
params := anthropic.MessageNewParams{
// Antes: {"type": "text_editor_20250124", "name": "str_replace_editor"}
// Después:
Tools: []anthropic.ToolUnionParam{
{OfTextEditor20250728: &anthropic.ToolTextEditor20250728Param{}},
},
// ...
}
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
// Antes: {"type": "text_editor_20250124", "name": "str_replace_editor"}
// Después:
.addTool(ToolTextEditor20250728.builder().build())
// ...
.build();
```
```php PHP
$message = $client->messages->create(
// Antes: ['type' => 'text_editor_20250124', 'name' => 'str_replace_editor']
// Después:
tools: [new ToolTextEditor20250728()],
// ...
);
```
```ruby Ruby
# Antes
legacy_tools = [{type: "text_editor_20250124", name: "str_replace_editor"}]
# Después
tools = [{type: "text_editor_20250728", name: "str_replace_based_edit_tool"}]
```
* **Editor de texto:** Usa `text_editor_20250728` y `str_replace_based_edit_tool`. Consulta la documentación de la [herramienta de editor de texto](https://platform.claude.com/docs/es/agents-and-tools/tool-use/text-editor-tool) para obtener más detalles.
* **Ejecución de código:** Actualiza a `code_execution_20260521`. Consulta la documentación de la [herramienta de ejecución de código](https://platform.claude.com/docs/es/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version) para ver las instrucciones de migración.
* **Uso de computadora:** En la API de Claude y Google Cloud, Claude Opus 5.5 acepta el uso de computadora solo como el conjunto de herramientas `computer_toolset_20260801`: las herramientas anteriores `computer_20250124` y `computer_20251124` se rechazan en esas plataformas. Consulta el [cambio incompatible del uso de computadora](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#computer-use-toolset).
3. **Gestiona el motivo de detención `refusal`**
Actualiza tu aplicación para [gestionar los motivos de detención `refusal`](https://platform.claude.com/docs/es/test-and-evaluate/strengthen-guardrails/handle-streaming-refusals):
```python Python
response = client.messages.create(...)
if response.stop_reason == "refusal":
# Maneja el rechazo de forma adecuada
pass
```
```typescript TypeScript
const response = await client.messages.create(/* ... */);
if (response.stop_reason === "refusal") {
// Maneja el rechazo de forma adecuada
}
```
```csharp C#
var response = await client.Messages.Create(...);
if (response.StopReason?.Value() == StopReason.Refusal)
{
// Maneja el rechazo de forma adecuada
}
```
```go Go
response, _ := client.Messages.New(ctx, params) // your existing request
if response.StopReason == anthropic.StopReasonRefusal {
// Maneja el rechazo de forma adecuada
}
```
```java Java
Message response = client.messages().create(...);
StopReason reason = response.stopReason().orElse(StopReason.END_TURN);
if (reason.equals(StopReason.REFUSAL)) {
// Maneja el rechazo de forma adecuada
}
```
```php PHP
$response = $client->messages->create(...);
if ($response->stopReason === 'refusal') {
// Maneja el rechazo de forma adecuada
}
```
```ruby Ruby
response = client.messages.create(...)
if response.stop_reason == :refusal
# Maneja el rechazo de forma adecuada
end
```
4. **Gestiona el motivo de detención `model_context_window_exceeded`**
Los modelos Claude 4.5 y posteriores devuelven un motivo de detención `model_context_window_exceeded` cuando la generación se detiene por alcanzar el límite de la ventana de contexto, en lugar del límite `max_tokens` solicitado. Actualiza tu aplicación para gestionar este nuevo motivo de detención:
```python Python
response = client.messages.create(...)
if response.stop_reason == "model_context_window_exceeded":
# Gestiona adecuadamente el límite de la ventana de contexto
pass
```
```typescript TypeScript
const response = await client.messages.create(/* ... */);
if (response.stop_reason === "model_context_window_exceeded") {
// Gestiona adecuadamente el límite de la ventana de contexto
}
```
```csharp C#
var response = await client.Messages.Create(...);
if (response.StopReason?.Raw() == "model_context_window_exceeded")
{
// Gestiona adecuadamente el límite de la ventana de contexto
}
```
```go Go
response, _ := client.Messages.New(ctx, params) // your existing request
if response.StopReason == "model_context_window_exceeded" {
// Maneja adecuadamente el límite de la ventana de contexto
}
```
```java Java
Message response = client.messages().create(...);
StopReason reason = response.stopReason().orElse(StopReason.END_TURN);
if (reason.equals(StopReason.of("model_context_window_exceeded"))) {
// Gestiona adecuadamente el límite de la ventana de contexto
}
```
```php PHP
$response = $client->messages->create(...);
if ($response->stopReason === 'model_context_window_exceeded') {
// Gestiona adecuadamente el límite de la ventana de contexto
}
```
```ruby Ruby
response = client.messages.create(...)
if response.stop_reason == :model_context_window_exceeded
# Maneja adecuadamente el límite de la ventana de contexto
end
```
5. **Verifica el manejo de parámetros de herramientas (saltos de línea finales)**
Los modelos Claude 4.5 y posteriores conservan los saltos de línea finales en los parámetros de cadena de las llamadas a herramientas, que antes se eliminaban. Si tus herramientas dependen de la coincidencia exacta de cadenas con los parámetros de las llamadas a herramientas, verifica que tu lógica maneje correctamente los saltos de línea finales.
6. **Actualiza tus prompts para los cambios de comportamiento**
Los modelos Claude 4 y posteriores tienen un estilo de comunicación más conciso y directo, y requieren instrucciones explícitas. Revisa las [mejores prácticas de prompting](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/claude-prompting-best-practices) para obtener orientación sobre optimización.
#### Cambios recomendados adicionales
* **Elimina los encabezados beta heredados:** Elimina `token-efficient-tools-2025-02-19` y `output-128k-2025-02-19`. Todos los modelos Claude 4 y posteriores tienen integrado un uso de herramientas eficiente en tokens, y estos encabezados no tienen ningún efecto.
## Migración a Claude Opus 5.5 desde Claude Sonnet 5
Revisa [Lo que debe cumplir cada solicitud a Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#request-requirements), [Gestiona el pensamiento en cada respuesta](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#thinking-in-every-response) y [Migración a Claude Opus 5.5 desde Claude Opus 5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-5). Usa `claude-sonnet-5` como el ID de modelo que reemplazas. Esa última sección se aplica al código en Claude Sonnet 5 tal como está escrito, porque Claude Sonnet 5, al igual que Claude Opus 5:
* Se ejecuta con el pensamiento activado de forma predeterminada y acepta `thinking: {"type": "disabled"}`, en su caso con cualquier nivel de esfuerzo.
* Acepta la elección forzada de herramientas y la herramienta `computer_20251124`.
* Devuelve el texto entre llamadas a herramientas como bloques `text`.
* Usa el esfuerzo `high` de forma predeterminada.
El pensamiento extendido manual, los parámetros de muestreo con valores no predeterminados y el prefill del asistente devuelven un error 400 en ambos modelos, así que nada cambia en ese aspecto. Ninguno de los cambios obligatorios de las secciones para Claude Opus 4.8, Claude Opus 4.7 y Claude Opus 4.6 se aplica a tu caso.
### Qué cambió
1. **Mensajes del sistema a mitad de la conversación:** En la API de Claude, Amazon Bedrock y Google Cloud, Claude Opus 5.5 acepta mensajes `role: "system"` inmediatamente después de un turno del usuario en el arreglo `messages` (sujeto a las [reglas de ubicación](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages#limitations)). Esta función no está disponible en Claude Sonnet 5. Si mantienes rutas de código que reconstruyen el historial completo de mensajes para actualizar instrucciones, puedes simplificarlas y conservar los aciertos de la [caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching) en turnos anteriores.
2. **Mínimo más bajo para el almacenamiento en caché de prompts:** La longitud mínima de prompt que admite el almacenamiento en caché de prompts en Claude Opus 5.5 es de 512 tokens, frente a 1,024 tokens en Claude Sonnet 5. Los prompts que eran demasiado cortos para almacenarse en caché en Claude Sonnet 5 ahora pueden crear entradas de caché, sin necesidad de cambios en el código. Consulta [Almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching#cache-limitations) para ver los mínimos por modelo.