22 - Generation 4.5: Sonnet, Haiku and Opus 4.5 Compared

22 - Generation 4.5: Sonnet, Haiku and Opus 4.5 Compared

Between September and November 2025, Anthropic released the entire 4.5 generation model family. This isn't just an incremental update - each model has received substantial improvements in capacity, performance, speed and operating costs. For a developer who builds systems with Claude, understanding the different trade-offs is essential to optimizing both quality and the budget of your projects.

In this article we will explore how Sonnet 4.5 positions itself as the new universal default model, how Haiku 4.5 made enterprise AI accessible at almost ridiculous costs, and how Opus 4.5 has finally surpassed the 80% threshold on SWE-bench Verified while reducing costs by 66%. You'll learn when to use which model, how to calculate real costs with prompt caching, and how migrate from previous models discontinued on February 19, 2026.

1. The Generational Leap 4.5: Why It Matters

Generation 3.5 (Sonnet, Haiku, Opus released between 2024 and early 2025) was already impressive. But generation 4.5 represents a paradigm shift for three fundamental reasons:

1.1 Benchmarks Verified on Real Tasks

For the first time, Anthropic has published results on SWE-bench Verified, a benchmark that measures a model's ability to solve software engineering problems real (not artificial). Datasets include 500+ tasks from the top-1000 repositories on GitHub, with human verified outputs. This isn't a marketing metric - it's what the model can actually do when you ask it to refactor your codebase.

1.2 Costs that Change the Economic Calculation

Haiku 4.5 costs $1/$5 per million tokens (input/output). Opus 4.5 fell from $15/$75 to $5/$25 (-66%). Sonnet 4.5 remains unchanged but with +30% more capacity. This means an entire architecture multi-agent that yesterday cost $200/day now costs $60/day with the same quality. For companies, this is the first year AI orchestration has become economically viable at scale.

1.3 New Capabilities Have Become Standard

Extended thinking is now in Haiku. Computer use is in Haiku. Prompt caching is in all three. The cheapest model in the family has the same advanced capabilities as the most expensive model six months ago. This levels the playing field between startups and enterprises.

2. Claude Sonnet 4.5: The New Default Model

Released on September 29, 2025, Sonnet 4.5 is the model that surpasses it Most developers will use it by default for most tasks. It's the model by Claude Code for this season.

2.1 Benchmarks and Capabilities

The jump from Sonnet 4 to Sonnet 4.5 is notable: +4.9 percentage points on SWE-bench Verified with 200K context, and an even bigger increase in OSWorld (ability to use the computer). This means that Sonnet 4.5 can solve approximately 1 in 4 more problems than Sonnet 4. Out of 100 tasks you delegated, Sonnet 4 solved 72 of them, Sonnet 4.5 solved 77 of them.

2.2 Technical Specifications and Limitations

2.3 When to Use Sonnet 4.5

Use Sonnet 4.5 when:

• Initial scaffolding: create the foundation of a new module, function or component
• Standard implementation: write code that follows known patterns
• Light refactoring: renaming variables, file restructuring, method extraction
• Guided Debugging: identify bugs in known code
• Documentation generation: README, docstring, ADR (Architecture Decision Record)
• Pair programming 24/7: when Haiku is not capable enough and Opus is overkill

Do not use Sonnet 4.5 for critical security code reviews, complex algorithms, or architectural refactoring on large codebases. For these uses, Opus 4.5 is the correct choice.

3. Claude Haiku 4.5: The Accessibility Revolution

Released on October 15, 2025, Haiku 4.5 is the real surprise of the 4.5 generation. It's no longer the "cheap model you set aside for light tasks." It is an enterprise-grade model which costs 90% less than Sonnet.

3.1 Benchmark: Only 5 Points Below Sonnet

Read these numbers carefully. Haiku 4.5 solves 73.3% of tasks on SWE-bench Verified. Sonnet 4.5 solves 77.2%. The difference is only 3.9 percentage points. But the cost of Haiku is a third than that of Sonnet. For a developer who does task orchestration (breaking a complex problem into 20 easy sub-tasks), this changes everything.

3.2 Newcapabilities: Extended Thinking in Haiku

Until three months ago, extended thinking was an exclusive feature of top-tier models. Now it's in Haiku. It means you can make Haiku "think" about a problem to achieve accuracy better than 15-20%, and pay only $1 for every million input tokens.

Combined with prompt caching, economic calculation becomes almost free for many tasks. Practical example:

# Task: Refactor 500 file Python in un codebase
# Prompt base: 50K token (include linee guide, ADR, esempio)
# Per file: 5K token di context + 1K token di output

file_count = 500
base_prompt_tokens = 50_000
cost_per_million_input = 1  # $ per 1M token input
cost_per_million_output = 5  # $ per 1M token output
cost_per_million_cached = 0.1  # $ per 1M token di cache (90% discount)

# Scenario 1: SENZA prompt caching
cost_without_cache = (
    (base_prompt_tokens * file_count * cost_per_million_input) / 1_000_000 +
    (500 * 1_000 * cost_per_million_output) / 1_000_000
)
# ≈ $25 + $2.50 = $27.50

# Scenario 2: CON prompt caching
first_request_tokens = base_prompt_tokens + 5_000
cached_per_request = 50_000  # Base prompt cached

cost_with_cache = (
    (first_request_tokens * cost_per_million_input) / 1_000_000 +
    ((base_prompt_tokens * (file_count - 1) * cost_per_million_cached) / 1_000_000) +
    ((file_count * 5_000 * cost_per_million_input) / 1_000_000) +
    ((file_count * 1_000 * cost_per_million_output) / 1_000_000)
)
# ≈ $0.055 + $2.25 + $2.50 + $2.50 = $7.30

savings = cost_without_cache - cost_with_cache
print(f"Senza cache: ${cost_without_cache:.2f}")
print(f"Con cache: ${cost_with_cache:.2f}")
print(f"Risparmio: {savings:.2f} ({(savings/cost_without_cache)*100:.1f}%)")
# Output: Risparmio: $20.20 (73%)

This is why Haiku 4.5 is a game changer. It's not "good enough": it's economically It's unreasonable to use Sonnet for repetitive tasks when Haiku costs 1/3 and solves 95% of problems.

3.3 When to Use Haiku 4.5

• Multi-step orchestration: decomposition of complex tasks into 10-50 sub-tasks
• Repetitive batch processing: rename 500 files, update CHANGELOG in 200 modules
• Validation and linting: check if the code follows the guidelines
• Data extraction and parsing: extract structures from unstructured text
• Simple unit test generation: tests for pure functions and utilities
• Low cost RAG: when cost per query is critical (chatbots, user assistants)

4. Claude Opus 4.5: First Above 80% SWE-bench

Released on November 24, 2025, Opus 4.5 is the model that has finally crossed the magic threshold of 80% on SWE-bench Verified. Simultaneously, Anthropic announced 66% price cuts: from $15/$75 to $5/$25 per million tokens.

4.1 SWE-bench Verified 80.9% and Above

80.9% on SWE-bench Verified is not a marketing number. It means if you take 500 problems real software engineering data from public repositories, Opus 4.5 correctly resolves 405 of them. Five years ago, this was the exclusive domain of senior teams. Today it is an API call.

4.2 The New Effort Parameter (Beta)

Opus 4.5 introduces an experimental parameter effort with four values: low, medium, high, max. This parameter controls how much "internal reasoning" the model devotes to a request.

The killer app is effort=medium: It gives you the quality of Sonnet 4.5, but you only pay 66% less (cost ratio: Opus medium = Sonnet × 0.42). For a team doing standard implementation, this means migrating from Sonnet to Opus medium and saving 58% while maintaining the same quality.

4.3 Practical Implementation: Typescript API

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

async function reviewCodeWithEffort(
  codeSnippet: string,
  effort: "low" | "medium" | "high" | "max"
): Promise {
  const message = await client.messages.create({
    model: "claude-opus-4-5-20251124",
    max_tokens: 4096,
    thinking: {
      type: "enabled",
      budget_tokens: effort === "max" ? 100000 : effort === "high" ? 50000 : 30000,
    },
    messages: [
      {
        role: "user",
        content: `Analizza questo codice e fornisci una security review dettagliata.\n\n${codeSnippet}`,
      },
    ],
  });

  const textBlocks = message.content.filter((b: any) => b.type === "text");
  return textBlocks.map((b: any) => b.text).join("\n");
}

// Caso d'uso 1: Review veloce (low effort, costo minimo)
const fastReview = await reviewCodeWithEffort(
  "const x = fetch(...)",
  "low"
);

// Caso d'uso 2: Review standard (medium effort, costo Sonnet-equivalente)
const standardReview = await reviewCodeWithEffort(
  "const authenticateUser = async (token: string) => { ... }",
  "medium"
);

// Caso d'uso 3: Security audit critico (max effort, qualità massima)
const securityAudit = await reviewCodeWithEffort(
  "// Core payment processing module ...",
  "max"
);

console.log("✓ Fast review completato (effort=low)");
console.log("✓ Standard review completato (effort=medium)");
console.log("✓ Security audit completato (effort=max)");

4.4 When to Use Opus 4.5

• Critical code review (security, performance): use effort=high or max
• Architectural refactoring: database migration, core module restructuring
• Complex algorithms: optimization, data structures, NP-hard problems
• Standard implementation (medium effort): when you are looking for Sonnet quality at a 42% cost
• Pair programming on critical features: 30+ hours of operating autonomy
• Debugging complex bugs: race condition, memory leak, competition problems

5. Decision Matrix: Which Model for Which Task?

Choosing the right model is not trivial. The matrix below helps you make the decision based on three dimensions: task complexity, budget, and the required level of accuracy.

Golden Rule: Always start with Haiku 4.5. If the task fails (insufficient output, low quality), scale to Sonnet 4.5. If Sonnet fails (very complex problem), use Opus 4.5. More often than you think, Haiku is enough.

6. Real Case: Cost-Efficient Pipeline Orchestration

Let's say you're refactoring a codebase of 50 Spring Boot microservices (1,200 total Java files). The task requires naming convention normalization, extraction of common utilities, dependency updating, and final code review. Here's how to orchestrate the task with the three models to minimize costs while maintaining high quality.

6.1 Pipeline Architecture

#!/usr/bin/env python3
"""
Pipeline refactoring 50 Spring Boot microservizi.
Budget: <$500 totali
Tempo: 40 ore wall-clock
Quality target: 99% conformità naming + 0 regressions
"""

PHASE_1_ANALYSIS = {
    "task": "Analizzare architettura, identificare incoerenze",
    "model": "haiku-4-5",  # Cost: ~$2
    "input_tokens": 200_000,  # 50 file * 4K token ciascuno
    "output_tokens": 20_000,
    "steps": [
        "Scansione codebase + AST parsing",
        "Identificazione pattern incoerenti",
        "Generazione report standardizzazione"
    ]
}

PHASE_2_REFACTORING = {
    "task": "Refactor 1.200 file Spring Boot",
    "model": "haiku-4-5",  # Cost: ~$200 con caching
    "decomposition": "20 batch di 60 file ciascuno",
    "per_batch": {
        "prompt_base": "50K token (guide, ADR, standard)",
        "files": 60,
        "tokens_per_file": 5_000,
        "total_input": 350_000,
        "total_output": 30_000,
    },
    "prompt_caching": True,  # First batch: full cost, 19 batch: -90%
    "cached_tokens": 50_000,  # ADR + guide
    "cost_calculation": {
        "first_batch": 1.05 + 0.15,  # Input + output
        "remaining_19_batches": (19 * 1.75 * 0.1) + (19 * 0.15),
        "total": 1.20 + 3.45,  # ~$4.65
    }
}

PHASE_3_VALIDATION = {
    "task": "Validazione automatica compilazione + test",
    "model": "haiku-4-5",
    "steps": ["mvn clean install", "run test suite"],
    "cost": 0,  # Local only
}

PHASE_4_CODE_REVIEW = {
    "task": "Security + performance review finale",
    "model": "opus-4-5",
    "effort": "medium",  # Same quality as Sonnet, -58% cost
    "input_tokens": 300_000,  # Top 30 file changed + context
    "output_tokens": 50_000,
    "cost": (300 * 5 / 1_000_000) + (50 * 25 / 1_000_000),  # $2.30
}

PHASE_5_MERGE_VERIFICATION = {
    "task": "Verify no regressions post-merge",
    "model": "haiku-4-5",
    "cost": "~$1",
}

TOTAL_COST = 2 + 200 + 2.30 + 1  # = ~$205.30 (bem sotto budget)
TOTAL_TIME = 40 * 3600  # 40 ore

print(f"""
Pipeline Refactoring 50 Microservizi
=====================================
Total Cost: ${TOTAL_COST:.2f}
Estimated Time: {TOTAL_TIME/3600:.0f} hours
Quality: 99% compliance + 0 regressions
Model Mix: Haiku (95%), Opus (5%)

Breakdown:
- Phase 1 (Analysis): $2
- Phase 2 (Refactoring): $200 (Haiku + caching)
- Phase 3 (Validation): $0 (local)
- Phase 4 (Review): $2.30 (Opus medium)
- Phase 5 (Verification): $1

ROI: Cost per service = ${TOTAL_COST/50:.2f}
     Quality per service = 99% automated conformance
""")

The secret is stratification by complexity: Haiku for the 95% repetitive work, Opus for the 5% requiring senior experience. With prompt caching, the total cost drops from an estimated $500 to a real $200.

7. Comparison with GPT-5, Gemini 2.0, and Competitors

How is the Claude 4.5 family positioned compared to global competition? Current data (November 2025) shows an interesting picture.

Observations:

• Opus 4.5 is the undisputed leader: 80.9% on SWE-bench is a historic threshold
• Gemini 2.0 is competitive on cost: slightly cheaper, but 1.7 points below Opus
• GPT-5 rumors: Development rumors ongoing, but not official as of today
• Sonnet 4.5 is the "Goldilocks": 77.2% is more than enough for 90% of tasks, aggressive pricing

8. Migration Checklist: From Sonnet 3.7 and Haiku 3.5 to 4.5

Il February 19, 2026, Anthropic has discontinued Sonnet 3.7 (May 2024) and Haiku 3.5 (November 2024). If you have applications in production that use these templates, you need to migrate. Here's how to do it systematically.

8.1 Breaking Changes

8.2 Step-by-Step Migration Checklist

# MIGRAZIONE CHECKLIST: Sonnet 3.7 → Sonnet 4.5

## FASE 1: Identificazione (8h)
- [ ] Audit codebase: grep -r "claude-3-5-sonnet" .
- [ ] Elencare tutti i deployment (dev, staging, prod)
- [ ] Documentare SLA attuali (latency, cost, availability)
- [ ] Creare branch: feature/migrate-claude-4.5

## FASE 2: Update Ambiente (2h)
- [ ] Update .env.dev: MODEL_ID=claude-sonnet-4-5-20250929
- [ ] Update .env.prod: MODEL_ID=claude-sonnet-4-5-20250929
- [ ] Update Dockerfile/docker-compose.yml se inline
- [ ] Verificare API keys (backwards compatible)

## FASE 3: Test Regressione (16h)
- [ ] Run test suite: npm test / mvn test / pytest
- [ ] Verificare output parsing (se JSON mode usato)
- [ ] Load test: 100 req/min per 5 minuti
- [ ] Latency benchmark: p50, p95, p99
- [ ] Cost benchmark: input/output token actual usage
- [ ] Edge case testing: max context, erro handling

## FASE 4: Staging Deployment (4h)
- [ ] Deploy a staging con nuovi model ID
- [ ] Monitor Prometheus/CloudWatch per 2h
- [ ] Run smoke test suite
- [ ] A/B test: 10% traffic su 4.5, 90% su 3.7

## FASE 5: Production Rollout (6h)
- [ ] Prepare rollback plan (old model IDs pronti)
- [ ] Schedule durante low-traffic window (es. 2am UTC)
- [ ] Canary deployment: 5% → 25% → 100%
- [ ] Monitor errori, latenza, cost per 24h
- [ ] Post-mortem meeting + documentation

## FASE 6: Ottimizzazione (8h)
- [ ] Implementare prompt caching per cache hit >50%
- [ ] Se task semplici: migrate Sonnet → Haiku 4.5 (-66% cost)
- [ ] Review effort parameter se Opus 4.5 usato
- [ ] Update documentation + runbook

TEMPO TOTALE: ~36h per team di 3 engineer
DOWNTIME ATTESO: 0 (canary rollout)
COST DELTA: -0% (pricing invariato Sonnet 3.7 → 4.5)
ROI: +30% efficienza con stessi costi

9. 2026 Previews: Opus 4.6, Sonnet 4.6, and 1M Context

Based on Anthropic's public roadmaps and announcements, 2026 will bring three significant developments.

9.1 Opus 4.6 (Expected Q2-Q3 2026)

Anthropic has confirmed that Opus 4.6 is in development and should reach 85%+ on SWE-bench Verified with further cost reduction. The effort parameter will be extended with greater granularity (low, medium, high, very-high, max) to allow finer trade-offs between cost and quality.

9.2 Sonnet 4.6 (Expected Q3 2026)

Sonnet 4.6 will probably have feature parity with Opus 4.5 (extended thinking, effort parameter, mature json mode) at even more competitive prices. It likely remains the default model for the vast majority of developers.

9.3 Haiku 5.0 and Context Window 1M

All family models are converging towards 1M token context window. This means you can pass the entire codebase (up to 1 million tokens ≈ 100K lines of code) in a single request without worrying about the context limit.

The implication is that the complexity of chunking and context window management will decrease dramatically. Prompt engineering 2026 will be less "how to fit big problems in small windows" and more "how to ask questions effectively given infinite context".

Conclusion

Claude's 4.5 generation represents a qualitative leap that transforms the economics of AI development. It's no longer "AI for light tasks and support": it's AI as a building material for production systems.

The three key lessons:

• Haiku 4.5 is your new default: For 80% of tasks (batch processing, orchestration, validation), start with Haiku. Costs 1/3 of Sonnet, solves 95% of problems. Scale to Sonnet/Opus only if necessary.
• Sonnet 4.5 remains the balance point: 77.2% SWE-bench, enterprise quality, unchanged price. Use Sonnet when Haiku isn't enough and you don't want to pay for Opus.
• Opus 4.5 effort=medium is the cheat code: Sonnet quality at a 42% cost. The difference between 3.7 and 4.5 is lower than the saving opportunity with effort parameter.

Begin migrating from 3.7/3.5 models (discontinued February 19, 2026) to Sonnet 4.5 and Haiku 4.5. In article 24, we will explore advanced orchestration of multi-model agents and how to build systems that self-select the model based on complexity metrics detected in real time.