Claude Haiku 5.5: qué mejora frente a Haiku 4.5 y para qué usarlo al programar

Claude Haiku 5.5 es el modelo más rápido y más barato de Anthropic en el momento de crear esta entrada, y desde el 7 de octubre de 2026 es el Haiku que usa Claude Code por defecto con la API de Anthropic, en lugar de Haiku 4.5. En esta entrada vamos a ver qué cambia frente a Haiku 4.5, cómo se comportan los 2 con 4 tareas reales de un proyecto Laravel y para qué tiene sentido usar Haiku 5.5 al programar.

Haiku 5.5 resolvió las 12 ejecuciones de la prueba, y Haiku 4.5 se quedó en 10 de 12. Las diferencias salieron en lo que no se ve a primera vista: los tests que escribió Haiku 5.5 detectaron más errores, no se equivocó al buscar las rutas públicas y, al añadir la cancelación de pedidos, necesitó la mitad de turnos y de tiempo.

Qué cambia frente a Haiku 4.5

Estos son los cambios que te afectan al programar, según la documentación de Anthropic sobre Haiku 5.5:

• En la API se pide como claude-haiku-5-5. Haiku 4.5 sigue disponible como modelo anterior, con el id claude-haiku-4-5-20251001.
• La ventana de contexto pasa de 200.000 a 1 millón de tokens, y la salida máxima, de 64.000 a 128.000 tokens. Un token es la unidad en la que el modelo cuenta el texto, más o menos una palabra corta o un trozo de una larga.
• Es el primer Haiku con effort, el parámetro que regula cuánto razona el modelo, con 5 niveles de low a max y medium por defecto. Haiku 4.5 solo tenía el razonamiento extendido manual, con un presupuesto fijo de tokens.
• Su conocimiento fiable llega hasta junio de 2026. El de Haiku 4.5 se quedaba en febrero de 2025.
• Cuenta en torno a un 30 % más de tokens que Haiku 4.5 para el mismo texto, porque usa el tokenizador, la forma de partir el texto en tokens, de los modelos 4.7 y posteriores. Tenlo en cuenta al comparar los tokens de los 2.
• Si lo llamas desde tu código con la API, pasarle temperature, top_p o top_k devuelve un error 400, igual que terminar los mensajes con una respuesta del asistente a medio escribir (el prefill) o pedir el razonamiento extendido con budget_tokens. La guía de migración explica cómo cambiar cada uno.

En su anuncio, Anthropic lo presenta como su modelo pequeño más barato, más rápido y más capaz, pensado para tareas de mucho volumen: resúmenes, clasificación, consultas y subagentes. En Terminal-Bench 4.0, una prueba de tareas en la terminal, pasa del 0,0 % de Haiku 4.5 al 39,2 %. Los precios de cada modelo los tienes en la página de precios de la API.

Haiku 5.5 en Claude Code

Claude Code añadió Haiku 5.5 el 7 de octubre de 2026 (notas de la versión). Desde entonces, con la API de Anthropic, el alias haiku apunta a Haiku 5.5, y eso afecta a todo lo que en tu configuración diga haiku: claude --model haiku, /model haiku y los subagentes con model: haiku. Con Amazon Bedrock, Google Cloud, Microsoft Foundry y Claude Platform on AWS, el alias sigue apuntando a Haiku 4.5, según la documentación de Claude Code.

Si un subagente o un flujo tuyo depende de Haiku 4.5 y quieres mantenerlo mientras pruebas el nuevo, la variable ANTHROPIC_DEFAULT_HAIKU_MODEL decide a qué modelo apunta el alias:

export ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001

Lo hemos comprobado con claude -p --model haiku --output-format json: sin la variable, el campo modelUsage del JSON de salida muestra claude-haiku-5-5, y con ella, claude-haiku-4-5-20251001. Ten en cuenta que esa variable cambia también el modelo de las tareas en segundo plano que Claude Code encarga a Haiku.

Cómo lo hemos probado

La idea es la misma que en la comparativa Claude Opus 5.5 vs Sonnet 5.5, pero con tareas acotadas, de las que se suelen encargar a un modelo rápido o a un subagente. El proyecto es una tienda pequeña con Laravel 13.35, PHP 8.5, Pest 5.3 y Larastan 3.13 en el nivel 6, sobre Sail. Larastan es el análisis estático de PHPStan con las reglas de Laravel. Cada modelo ha hecho las 4 tareas 3 veces, siempre desde el mismo commit del proyecto y con el mismo prompt, lanzadas con claude -p en Claude Code 2.1.296. Haiku 5.5 trabaja con su effort por defecto, medium, y Haiku 4.5 no admite effort.

Una ejecución solo cuenta como correcta si pasa una comprobación objetiva: tests ocultos (tests que el modelo no ve), Larastan sin errores o una respuesta esperada, según la tarea. Las cifras de cada tarea son la mediana de sus 3 ejecuciones, es decir, el valor del medio. La duración, los turnos y los tokens salen del JSON que devuelve claude -p. Un turno es cada vuelta del agente: el modelo responde, usa una herramienta y recibe el resultado.

Resultados de cada tarea

Escribir tests

La primera tarea es escribir con Pest los tests de OrderPricing, la clase que calcula el total de un pedido: subtotal, 2 cupones de descuento, IVA del 21 % redondeado al céntimo y envío gratis a partir de 50 euros. El prompt pide cubrir todo su comportamiento, casos límite incluidos, sin tocar nada de app/.

Que los tests pasen no significa que detecten errores. Para comprobarlo, hemos preparado 10 copias de la clase con un error distinto cada una, como el IVA truncado en vez de redondeado o el envío gratis que empieza un céntimo más tarde. Después lanzamos los tests del modelo contra cada copia y contamos cuántos errores detectan, es decir, en cuántas copias falla al menos un test. Es la misma idea que las pruebas de mutación, pero con los errores escritos a mano.

Los 2 modelos resolvieron la tarea en las 3 ejecuciones. Los tests de Haiku 5.5 detectaron los 10 errores en las 3, y los de Haiku 4.5, 9, 7 y 9. Haiku 4.5 tardó 42 segundos, en 5 turnos y con 6.585 tokens de salida, y Haiku 5.5, 44 segundos, en 7 turnos y con 10.040 tokens.

Los 2 escribieron muchos tests: entre 22 y 40 Haiku 4.5, y entre 34 y 47 Haiku 5.5, contando como un test cada caso de los datasets de Pest. La diferencia está en qué comprueban. En las 3 ejecuciones de Haiku 4.5 quedó sin detectar el mismo error, el IVA truncado: ninguno de sus tests usa un importe cuyo IVA obligue a redondear hacia arriba, así que el redondeo nunca se pone a prueba. En una de ellas quedaron sin detectar 2 más: el envío gratis calculado sobre el subtotal antes del descuento y el cupón de 5 euros que no se limita al valor del pedido. Haiku 5.5 cubrió los 3 casos en sus 3 ejecuciones.

Para llegar ahí, Haiku 5.5 razona bastante más: dedicó a pensar entre 4.381 y 10.930 tokens por ejecución, y Haiku 4.5, unos 800. Por eso genera más tokens de salida aunque tarde más o menos lo mismo.

Cancelar pedidos

La segunda tarea es añadir la cancelación de pedidos con la ruta POST /orders/{order}/cancel, solo para usuarios con sesión iniciada. Solo puede cancelar el dueño del pedido, a través de OrderPolicy, y solo los pedidos pendientes o pagados. Al cancelar, cada producto recupera en su stock la cantidad de sus líneas, todo en una transacción. El prompt pide también los tests y dejar la suite y Larastan en verde. Para darla por buena tienen que pasar 7 tests ocultos y la suite del proyecto, con Larastan sin errores.

Los 2 modelos la resolvieron en las 3 ejecuciones, y aquí está la diferencia más grande de la prueba. Haiku 4.5 tardó 71 segundos, en 23 turnos y con 7.362 tokens de salida. Haiku 5.5 tardó 36 segundos, en 13 turnos y con 7.190 tokens. Es la tarea en la que más hay que ir y volver entre el código, los tests y Larastan, y Haiku 5.5 la resolvió con la mitad de turnos y en la mitad de tiempo. El contexto que leyó entre todas sus peticiones fue de 279.454 tokens, frente a los 704.725 de Haiku 4.5, y eso con un tokenizador que cuenta más tokens para el mismo texto.

Los 6 resultados pasan los tests ocultos, pero no hacen lo mismo. Las 3 ejecuciones de Haiku 4.5 comprueban el estado del pedido antes de abrir la transacción y sin bloquear nada:

if (!in_array($order->status, [OrderStatus::Pending, OrderStatus::Paid])) {
    throw ValidationException::withMessages(['order' => 'Este pedido no puede ser cancelado.']);
}

DB::transaction(function () use ($order) {
    $order->update([
        'status' => OrderStatus::Cancelled,
        'cancelled_at' => now(),
    ]);

    foreach ($order->items as $item) {
        $item->product->increment('stock', $item->quantity);
    }
});

Si llegan 2 peticiones de cancelación a la vez, las 2 pueden ver el pedido como pending y devolver el stock 2 veces. Las 3 de Haiku 5.5 bloquean la fila del pedido con lockForUpdate() en la transacción y comprueban el estado ya bloqueado:

DB::transaction(function () use ($order) {
    $locked = Order::query()->whereKey($order->id)->lockForUpdate()->firstOrFail();

    if (! in_array($locked->status, [OrderStatus::Pending, OrderStatus::Paid], true)) {
        throw ValidationException::withMessages(['order' => 'Solo se pueden cancelar pedidos pendientes o pagados.']);
    }

    foreach ($locked->items as $item) {
        Product::query()->whereKey($item->product_id)->increment('stock', $item->quantity);
    }

    $locked->update([
        'status' => OrderStatus::Cancelled,
        'cancelled_at' => now(),
    ]);
});

Ningún test oculto prueba 2 peticiones a la vez, así que esa diferencia no aparece en los resultados. Los 2 modelos añadieron un método cancel() a OrderPolicy en las 6 ejecuciones.

Corregir los errores de Larastan

La tercera tarea parte de una versión del proyecto con una exportación de ventas a CSV que da 7 errores de Larastan. 6 son tipos que faltan. El séptimo es un fallo de verdad: el CSV lee $product->title, una columna que no existe, y la buena es name. El prompt pide corregirlos todos sin ignorarlos: nada de @phpstan-ignore, baseline ni cambios en phpstan.neon. Para darla por buena, Larastan tiene que salir sin errores y tienen que pasar la suite y un test oculto de la exportación.

Los 2 la resolvieron en las 3 ejecuciones. Haiku 4.5 tardó 38 segundos, en 16 turnos y con 3.752 tokens, y Haiku 5.5, 30 segundos, en 13 turnos y con 4.525 tokens. En el código no hubo diferencia: las 6 ejecuciones cambiaron title por name y añadieron los tipos que faltaban, con 11 líneas añadidas y 5 quitadas en todas. Con una lista de errores concreta delante, los 2 cumplen igual de bien.

Encontrar las rutas públicas

La última tarea es la típica de un subagente de exploración: sin modificar nada, el modelo tiene que decir a qué rutas de la aplicación puede acceder un visitante sin iniciar sesión. Para esta tarea solo tiene las herramientas de lectura de Claude Code (Read, Grep y Glob).

Tiene 2 trampas. Las rutas de la cuenta están en un archivo aparte que routes/web.php carga en un grupo con el middleware auth. Y la ruta de la factura, orders/{order}/invoice, está fuera de cualquier grupo, pero su controlador implementa HasMiddleware, la interfaz con la que un controlador declara su propio middleware, y exige sesión. La respuesta correcta son 6 rutas, las mismas que php artisan route:list muestra sin el middleware auth.

Haiku 5.5 acertó las 6 rutas en las 3 ejecuciones, y Haiku 4.5, solo en 1 de 3. En las otras 2, las 2 en 7 turnos, Haiku 4.5 dio por pública orders/{order}/invoice sin ver que su controlador exige sesión. Haiku 4.5 tardó 13 segundos, en 7 turnos y con 1.483 tokens, y Haiku 5.5, 16 segundos, en 12 turnos y con 3.280 tokens. En lo demás, los 6 resultados coinciden: ninguno dio por públicas las rutas de la cuenta, y todos encontraron reports/sales, el informe de ventas que se quedó sin proteger.

Si te fijas, Haiku 5.5 necesitó entre 12 y 15 turnos. Con solo herramientas de lectura, cada turno de más es una consulta más al código antes de responder. Las 2 ejecuciones de Haiku 4.5 que fallaron respondieron en 7 turnos, y la que acertó, en 10.

Cuándo usar Haiku 5.5

Con estos datos, Haiku 5.5 puede ocupar el sitio de Haiku 4.5 en las tareas que se le encargaban. Resolvió todo lo que le pedimos, sus tests cubrieron más casos límite, acertó siempre en la exploración de solo lectura y en la cancelación necesitó la mitad de turnos. A cambio, en las tareas más sencillas tarda más o menos lo mismo y genera más tokens, porque razona más.

Nuestra recomendación es usarlo como modelo de los subagentes de exploración, de los que escriben tests de una clase concreta y de las correcciones acotadas, como los errores de Larastan. Para una función con una especificación clara también ha cumplido, pero si la tarea toca concurrencia, dinero o permisos, revisa el código aunque los tests pasen. Y si lo que quieres es elegir entre los modelos grandes para el trabajo principal, tienes la comparativa Claude Opus 5.5 vs Sonnet 5.5.

Ten en cuenta el alcance: son 4 tareas pequeñas, con 3 repeticiones y sobre un proyecto pequeño. Con tareas largas o un proyecto grande, la diferencia puede ser otra.

Cómo se asigna un modelo a un subagente con model: haiku lo tienes en la lección Qué son los subagentes de Claude Code y cuándo usarlos, y los alias y el effort de cada modelo, en Qué modelo usar en Claude Code. Si vienes de la generación anterior, el artículo de Claude Haiku 4.5 te sirve para ver de dónde venía.

Espero que te sirva. Si quieres aprender a trabajar con Claude Code en tus proyectos de principio a fin, no te pierdas el curso Claude Code.