Frontier AI Field Notes: Fable 5, Sonnet 5, and GPT-5.5

Models are starting to feel less like static products and more like market conditions. A model can launch, get discounted, get rate-limited, disappear, come back with new safeguards, or quietly behave differently inside the same workflow.

That makes the old question, "Which model is best?" less useful than a more operational question:

What work should I route to each model while the economics and availability make sense?

My short take after comparing several real coding-agent sessions: new Fable 5 does not feel as powerful as old Fable 5 at first glance. It still produced quality output, but it felt slower and less transparent. Sonnet 5 felt similar to Opus 4.8 in practical software work, maybe less powerful in some areas. GPT-5.5 felt surprisingly close to all of them when the surrounding workflow was strong.

This is not a lab benchmark. It is field evidence from real agentic software work: codebase scans, architecture review, security posture review, CI hardening, performance work, issue triage, pull requests, and operational debugging. Project names and sensitive product details are intentionally removed.

Why this matters now

The window for using premium models cheaply or freely can be short.

Anthropic restored Claude Fable 5 access after export controls were lifted. The restored access window matters: Anthropic said Fable 5 would be included for up to 50% of weekly usage limits through July 7, 2026, then move to usage credits. Anthropic also lists Fable 5 API pricing at $10 per million input tokens and $50 per million output tokens, with prompt-cache discounts available.

Claude Sonnet 5 launched with introductory API pricing of $2 per million input tokens and $10 per million output tokens through August 31, 2026, then moves to $3 and $15. Anthropic describes Sonnet 5 as close to Opus 4.8 on some agentic tasks at lower cost, especially with higher effort settings.

OpenAI says GPT-5.5 is available in ChatGPT and Codex, and that API pricing will be $5 per million input tokens and $30 per million output tokens, with a 1M context window for API developers. In Codex, OpenAI says GPT-5.5 has a 400K context window.

The practical lesson: when a frontier model is temporarily available, discounted, or rate-favorable, do not spend the best model on routine autocomplete. Use it for high-value work.

The field data

I compared retained session transcripts and GitHub metadata across several real agent runs. The table below summarizes the anonymized output.

Run	Work type	Measured output	What it showed
Old Fable 5 evidence	Broad product and engineering sweep	147 GitHub artifacts: 116 inferred issues, 31 confirmed AI PRs, 30 merged PRs, +4,519/-615 lines across 255 changed files	The most explosive run: wide discovery, backlog creation, many small and medium fixes, and strong follow-through.
New Fable 5	Automation and infrastructure tuning	18 commits, 11 tracked improvement items, 7 resolved, 5 root-cause analyses, 33 monitored units, doubled pipeline capacity	Quality work, but more like a careful senior operator than a high-throughput factory.
Sonnet 5	Architecture audit and app hardening	2 merged PRs, 11 bugs fixed, +838/-125 lines across 43 changed files, 4 parallel audit agents	The cleanest signal-to-code ratio: sharp review, targeted fixes, good tests, little waste.
GPT-5.5 feature-parity run	Migration and validation	206 completed turns, 8,672 tool calls, 2,056 test/build commands, one major PR merged +614/-73 across 23 files	Exhaustive, persistent, test-heavy, and very effective when the goal required grinding through many checks.
GPT-5.5 operations run	Operational review and queue repair	217.8 active minutes, 998 tool calls, one targeted PR merged +45/-24	Methodical diagnostics and strong guardrail thinking, with lower artifact volume.

The old Fable 5 comparison has one caveat: I do not have the raw old transcript retained locally. The PR count and line totals are confirmed from GitHub metadata, and the issue count is inferred from timestamped issue batches and repeated structure. That makes it good field evidence, not a perfect apples-to-apples transcript comparison.

What felt different

Model	Field impression	Strengths	Watchouts
Old Fable 5	Most explosive	Broad discovery, issue generation, many small and medium PRs, end-to-end follow-through	Raw transcript was not retained, so the comparison relies on artifact evidence.
New Fable 5	High quality, less obviously dominant	Root-cause analysis, long-running ops work, careful recovery, persistence through messy failures	Felt slower and less visible while working. New safeguards may also change some debugging and security-adjacent workflows.
Sonnet 5	Efficient and practical	Architecture review, security posture, targeted fixes, tests, code review response	Feels close to Opus 4.8 in many practical coding tasks, but not clearly stronger.
GPT-5.5	Comparable when the harness is strong	Long context, persistence, heavy tool use, tests, CI debugging, migration work	Can be verbose and tool-heavy. It benefits from strong stop conditions and clear validation targets.

The biggest surprise: GPT-5.5 did not feel far behind the Claude models in real software-agent work. Once the harness supplied the same repo access, tools, tests, review loops, and operating rules, the models clustered closer together than the hype cycle suggests.

The workflow mattered as much as the model.

Use limited premium access on high-value work

If Fable-class or discounted Sonnet-class access is temporary, I would spend it on work with compounding value.

High-value use	Why it is worth premium tokens
Architecture review	Finds systemic problems that affect every future feature.
Security posture review	Expensive to do manually, high downside if missed.
Cross-platform parity audit	Great models can compare behavior across web, mobile, APIs, docs, and tests.
CI and release gate review	Prevents silent failure paths from becoming production habits.
Performance and reliability sweep	Turns scattered symptoms into prioritized fixes.
Test strategy review	Finds where your test suite gives false confidence.
Backlog shaping	Converts vague product gaps into implementable, reviewable work.
Root-cause analysis	Premium models are valuable when the answer spans logs, code, infrastructure, and history.

Use cheaper or more available models for routine follow-up: formatting, narrow bug fixes, test updates, documentation cleanup, and repetitive implementation once the expensive model has mapped the terrain.

My routing strategy

Task	Best first choice
Big unknown codebase scan	Fable 5 or Sonnet 5 at high effort
Architecture or security review	Sonnet 5 or Fable 5
Long implementation with lots of test loops	GPT-5.5 or Sonnet 5
Operational debugging across logs and infrastructure	New Fable 5 or GPT-5.5
Many small backlog PRs	Old Fable-style workflow if available; otherwise GPT-5.5 or Sonnet with automation
Routine code cleanup	Cheaper model or lower effort
Sensitive enterprise work	Route by data retention, access controls, and auditability before raw intelligence

The key is not loyalty to one model. The key is routing.

The bigger lesson

Models are now part of the operating environment. They have pricing, rate limits, safety behavior, retention terms, regional availability, and sometimes government-driven access changes. That means AI software delivery needs the same resilience we expect from any production dependency.

You need portable instructions, source-controlled workflows, review gates, cost dashboards, model-routing rules, clear data classification, fallback paths, and session history that lets you compare outcomes after the fact.

The durable advantage is not picking the best model once. It is building an operating model that can notice when the best tool changes and move work accordingly.

New Fable 5 is still good, but it does not immediately feel like old Fable 5. Sonnet 5 is a strong practical coding model and may be close enough to Opus 4.8 for many tasks. GPT-5.5 is absolutely in the same conversation when the harness is good.

So while premium Claude access is available or discounted, I would use it aggressively for the highest-leverage work: scan the codebase, find architecture problems, assess security posture, inspect CI and release gates, and create the backlog that cheaper models can execute later.

Go big while you have it.