Claude Fable 5 vs GPT-5.5: How a max_tokens Misread Changed the Model Comparison

Claude Fable 5 vs GPT-5.5: How a max_tokens Misread Changed the Model Comparison#

The short conclusion: this was not a case where “Claude Fable 5 could not write an animation.” It was a case where the original max_tokens setting caused a misleading result.

In the first same-parameter run, gpt-5.5 returned a complete HTML file and passed browser validation. claude-fable-5 returned an incomplete animation file, which initially looked like a long-code failure. But the response metadata showed the real issue:

finish_reason = length
completion_tokens = 3200
max_tokens = 3200

That means the output budget was exhausted. The server stopped the response because the configured output limit was reached. When claude-fable-5 was retested with max_tokens=8000, it returned complete HTML with finish_reason=stop, and the animation passed browser validation.

This article documents the test design, the three tasks, the first misread, the Claude Fable 5 retest, and the methodology we should use for future long-code model comparisons.

Last updated: 2026-07-06.

Quick Answer#

The result is more nuanced than a simple win/loss table.

The corrected takeaway:

GPT-5.5 was more reliable under the lower output budget.
Claude Fable 5 did not fail the animation task as a capability issue; it needed a larger output budget.

For short reasoning tasks, both models performed well in this test. For full-page code generation, animations, tools, and other long outputs, you must check max_tokens, completion_tokens, finish_reason, and real runtime validation.

You can reproduce similar OpenAI-compatible requests through Crazyrouter:

https://crazyrouter.com/register?utm_source=crazyrouter_blog&utm_medium=article&utm_campaign=model_compare_series_20260706&utm_content=claude-fable-5-vs-gpt-55-max-tokens-animation-test-2026-en__quick_answer

Test Environment#

The test used Crazyrouter's OpenAI-compatible API.

Base URL: https://cn.crazyrouter.com/v1
Endpoint: POST /v1/chat/completions
Test date: 2026-07-06
Models:
- claude-fable-5
- gpt-5.5
temperature: 0.2

The API endpoint above should not include UTM parameters. Registration links can include UTM parameters; API base URLs should not.

A minimal request example:

curl https://cn.crazyrouter.com/v1/chat/completions \
  -H "Authorization: Bearer $CRAZYROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5",
    "messages": [
      {
        "role": "user",
        "content": "Toss a fair coin until HH appears for the first time. Compute the expected number of tosses and show the derivation."
      }
    ],
    "temperature": 0.2,
    "max_tokens": 3200
  }'

To run the comparison against GPT-5.5, use the same request and change only the model field.

Why These Tasks Were Used#

Short multiple-choice questions often produce “both are correct” results. They are useful for smoke testing, but they rarely reveal failures that happen in real workflows.

This test used three task types:

The first two tasks test reasoning accuracy. The third task tests output length, structural consistency, code completeness, and runtime behavior.

This matters because production failures are often not “the model knows nothing.” They are more often:

the output was truncated
an event handler was missing
a closing tag was missing
the code looked complete but failed in the browser
static checks passed but the Canvas did not animate

Task 1: Toss a Coin Until HH#

Prompt:

Toss a fair coin until the first occurrence of two consecutive heads, HH.
1. Find the expected stopping time.
2. Use state equations or recursion, not just the final answer.
3. Explain in one sentence why the answer is not 4.

The standard solution defines two states:

E0: no current H prefix
E1: the last toss was H, waiting for another H

E0 = 1 + 1/2 E1 + 1/2 E0
E1 = 1 + 1/2 * 0 + 1/2 E0

Solving gives E0 = 6

Results:

This task did not separate the models. Both avoided the tempting but wrong 1 / (1/4) = 4 shortcut.

Task 2: Bullet, Block, Spring, and Friction#

Task summary:

A bullet with m = 0.02 kg and v = 300 m/s embeds into a stationary block.
The block has M = 1.98 kg and is connected to a spring with k = 800 N/m.
The table has kinetic friction coefficient μ = 0.10, and g = 9.8 m/s^2.

Find:
1. The shared velocity immediately after collision.
2. The maximum spring compression.
3. Explain where momentum conservation is used, where the energy relation is used, and why mechanical energy is not conserved across the whole collision process.

Standard calculation:

During collision:
mv = (M + m)V
V = 0.02 * 300 / 2.00 = 3.0 m/s

After collision, during compression:
1/2(M + m)V^2 = 1/2kx^2 + μ(M + m)gx
9 = 400x^2 + 1.96x
x ≈ 0.148 m

Results:

Again, both models were correct. Both used momentum conservation for the short collision and energy accounting after the collision, including work done against friction.

Task 3: Generate a Canvas Animation#

This was the most informative task in the round.

The requirement was a complete single-file HTML artifact, not just a JavaScript snippet:

800x500 canvas
central star
at least 5 orbiting particles
requestAnimationFrame
translucent trails
pause/resume button
reset button
speed slider
FPS and speed HUD
must include init / update / draw / animate
no external libraries, images, or network resources

This tests four things at once:

First Result: GPT-5.5 Completed, Claude Was Truncated#

In the original same-parameter run, both models used max_tokens=3200.

gpt-5.5 returned complete HTML:

finish_reason = stop
included <!DOCTYPE html>
included </html>
included requestAnimationFrame
included init / update / draw / animate
included pause, reset, and speed slider controls
canvas = 800x500

Browser validation:

console errors: none
canvas size: 800x500
controls: present
changedPixels after 700ms = 37512
hasAnimation = true

This confirmed that the output was not just a static drawing. It was actually animating.

claude-fable-5 started in the right direction. It created an 800x500 canvas, particle configuration, orbits, a central star, a HUD, control styling, and began implementing init, update, and draw. But the file stopped mid-output.

Key metadata:

max_tokens = 3200
finish_reason = length
completion_tokens = 3200
HTML was truncated
no complete </script>
no </body>
no </html>

For a task that requires a runnable HTML animation, that artifact could not be counted as complete.

Why the First Interpretation Was Wrong#

If you only inspect the output file, it is easy to write the wrong conclusion:

GPT-5.5 can write the animation; Claude Fable 5 cannot.

But finish_reason=length changes the interpretation.

In Chat Completions, finish_reason=length usually means the output reached the configured length limit. Combined with:

completion_tokens = 3200
max_tokens = 3200

it indicates that the response did not naturally finish. It hit the output budget.

So the first failed artifact should not be treated as direct evidence that the model lacked the ability. The better hypothesis was that the HTML file needed more than 3200 output tokens.

Claude Fable 5 Retest: max_tokens Raised to 8000#

To verify that hypothesis, claude-fable-5 was retested on the same animation task.

This is the decisive part:

At max_tokens=3200, Claude again exhausted the output budget.
At max_tokens=8000, it naturally stopped after 3975 completion tokens.

The animation task required slightly more than 3200 output tokens, but nowhere near 8000. The original setting was simply too tight.

Claude Fable 5's 8000-token version also passed browser validation:

console errors: none
canvas size: 800x500
pause button: present
reset button: present
speed slider: present
changedPixels after 700ms = 15795
hasAnimation = true

The corrected conclusion:

Claude Fable 5 did not fail to complete the animation task as a capability issue.
It could not fit the full answer into max_tokens=3200; with max_tokens=8000, it completed and ran.

Full Result Table#

Latency records:

Claude returned faster in this run. But for long-code tasks, speed must be interpreted together with output budget. A faster truncated response is not a completed artifact.

Manual Scoring#

This scoring separates two different questions:

How did the models behave under the same calling constraints?
What can the model do when given a sufficient output budget?

Under max_tokens=3200, GPT-5.5 was steadier. With a sufficient budget, Claude Fable 5 did not fail the animation task.

Practical Model Selection Advice#

For tasks such as:

math derivation
physics explanation
short code
structured explanation
small JSON output

this test did not reveal a major correctness gap.

For tasks such as:

complete HTML generation
long JavaScript files
interactive frontend demos
full tool pages
large config files or test suites

you should not compare only the visible answer. You should also log:

Without these fields, long-code comparisons are easy to misread.

Recommended Comparison Record#

A long-code model comparison should save metadata like this:

{
  "task_id": "CODE-003-ANIM",
  "model": "claude-fable-5",
  "endpoint": "/v1/chat/completions",
  "max_tokens": 8000,
  "temperature": 0.2,
  "http_status": 200,
  "requested_model": "claude-fable-5",
  "returned_model": "claude-fable-5",
  "finish_reason": "stop",
  "completion_tokens": 3975,
  "validation": {
    "console_errors": 0,
    "canvas": "800x500",
    "changed_pixels_after_700ms": 15795,
    "has_animation": true
  }
}

The conclusion should be based not only on model text, but also on the metadata and runtime evidence.

You can run similar tests with the Crazyrouter OpenAI-compatible API:

https://crazyrouter.com/register?utm_source=crazyrouter_blog&utm_medium=article&utm_campaign=model_compare_series_20260706&utm_content=claude-fable-5-vs-gpt-55-max-tokens-animation-test-2026-en__api_example

Related Comparisons#

This article is a methodology correction for the model comparison series.

Related Crazyrouter articles:

• Claude Fable 5 vs Claude Sonnet 5 API behavior test
• Claude Sonnet 5 vs GPT-5.4 API comparison
• DeepSeek V4 Pro compatibility with Codex and Claude Code
• Common gpt-image-2 ecommerce failure reasons
• OpenRouter alternatives for production teams

The common principle: do not judge model behavior from marketing pages or HTTP 200 alone. Use real payloads, real responses, failure metadata, and runtime validation.

FAQ#

Does this prove GPT-5.5 is always stronger than Claude Fable 5?#

No. It shows that GPT-5.5 was more reliable under the original max_tokens=3200 animation setting. Claude Fable 5 completed the task when the output budget was increased.

Why is finish_reason=length important?#

It indicates that the response did not stop naturally. For long-code tasks, this often means missing closing tags, missing event handlers, or incomplete functions.

Why not look only at completion_tokens?#

completion_tokens=3200 means little by itself. It becomes meaningful when compared with max_tokens=3200; equality strongly suggests the output budget was reached.

Why use browser validation?#

Generated code should not be judged only by text inspection. The browser check verifies console errors, Canvas size, controls, and real pixel changes over time.

How large should max_tokens be for long code?#

There is no universal number. For complete HTML pages with CSS and JavaScript, a tight output budget is risky. If you see finish_reason=length, raise max_tokens and retest before judging the model.

Can this test decide production routing?#

It can inform routing, but it should not be the only factor. Production routing should also consider cost, latency, context length, structured output stability, failure rate, retry behavior, and task type.

Final Verdict#

The important result is not that one model permanently beats the other. The important result is that the first conclusion was too shallow.

Original run:

GPT-5.5: max_tokens=3200, complete HTML, browser validation passed.
Claude Fable 5: max_tokens=3200, finish_reason=length, completion_tokens=3200, output truncated.

Retest:

Claude Fable 5: max_tokens=8000, finish_reason=stop, completion_tokens=3975, complete HTML, browser validation passed.

Final conclusion:

GPT-5.5 was steadier under the lower output budget.
Claude Fable 5 could complete the animation task when given enough output budget.
Long-code model comparisons must record max_tokens, completion_tokens, finish_reason, and runtime validation.

Future model comparisons should treat these fields as required evidence. Otherwise, an output-budget issue can be incorrectly reported as a model capability failure.