Claude Opus 5 vs Claude Fable 5: A Seven-Task Real API Benchmark and Production Routing Notes

Claude Opus 5 vs Claude Fable 5: 7 Real API Tests and Production Routing Advice#

How should you choose between Claude Opus 5 and Claude Fable 5? If you only look at a single successful answer, both models can produce polished mathematical derivations. In production, however, the experience is usually shaped by three other questions: can the task be delivered reliably, is latency suitable for interactive use, and can the system recover automatically after failures?

On July 25, 2026, we tested the two models across 7 task categories through the same OpenAI-compatible API, using identical prompts and parameters. The results did not fit the simplistic story that “the larger model is always better”:

• claude-fable-5 was faster and more concise on tasks where both models succeeded;
• claude-opus-5 ultimately covered all 7 task categories;
• Fable 5 repeatedly triggered content_filter on ordinary code-review and incident-JSON prompts;
• On the physics task, Opus 5 returned HTTP 200 twice but answered only with an unrelated greeting; it completed normally on the third attempt.

That means production model selection should not boil down to a single model ID. A safer pattern is: choose the primary model by task type, then wrap abnormal cases with content validation, retries, and model fallback.

Test Opus 5 and Fable 5 through the same API

Quick Takeaways#

If your input types are unpredictable, or if you need to minimize false filtering on ordinary business prompts, Opus 5 deserves priority. If the task structure is fixed, has already been regression-tested, and interactive speed and output length matter more, Fable 5 is a better first hop.

How We Tested#

Before testing, we called the model-list endpoint to confirm that both exact model IDs were visible:

GET https://cn.crazyrouter.com/v1/models

claude-opus-5
claude-fable-5

All formal requests used the same endpoint:

POST https://cn.crazyrouter.com/v1/chat/completions

The shared conditions were:

Same system prompt
Same user prompt
temperature = 1
Same max_tokens for each task
stream = true
No tools or web access enabled

The unified system prompt only asked the model to answer accurately and follow the requested format. It did not add any role framing that favored either model:

Answer the user's task accurately. Follow every requested output format and length constraint exactly. Do not use external tools.

We recorded more than the final text:

• HTTP status and finish_reason;
• response ID and returned model;
• time to first visible token and total latency;
• completion tokens and reasoning tokens;
• whether the visible answer satisfied task-level acceptance checks;
• whether abnormal requests recovered when retried with the same parameters.

This is an end-to-end Crazyrouter gateway test, not an experiment pinned to a single upstream channel. The results therefore reflect model behavior, upstream filtering, gateway routing, and the channel state at that moment. They are useful for answering “what will users actually encounter through this API,” not for constructing a pure offline capability leaderboard for the Claude family.

For more on why model tests must record finish_reason and output budget, see the Claude Fable 5 vs GPT-5.5 max_tokens retest.

Summary Table for the 7 Tasks#

One-shot delivery rate in the main test:

Claude Opus 5: 6 / 7 = 85.7%
Claude Fable 5: 5 / 7 = 71.4%

After retry:

Claude Opus 5: 7 / 7
Claude Fable 5: 5 / 7

Here, “delivery” does not mean the request succeeded. It means the business received a visible answer that satisfied the task requirements. If HTTP 200, the model name, and token usage are present but the body is empty, filtered, or only returns a greeting, the task still counts as failed.

Math, Constraints, and Statistics: Both Models Were Reliable#

The math task used a three-state Markov chain and asked for the waiting time until first reaching state 3 from state 1:

E1[τ]
E1[τ²]
Var1(τ)

Both models returned:

E1[τ] = 5
E1[τ²] = 43
Var1(τ) = 18

They also wrote out the transient matrix Q and the equations for the first and second moments. This was not a case where the final numbers were correct but the derivation was inconsistent.

The constraint-search task asked the model to place talks A, B, C, D, and E into five time slots while satisfying adjacency, ordering, gap, and non-adjacency constraints. Both models found the unique sequence:

A, C, E, B, D

The statistical-correction task deliberately supplied a false conclusion: “The mean is 10 and the variance is 4, so P(X≥14)=0.5.” Both models noted that two moments are insufficient to uniquely determine the tail probability, and used the one-sided Chebyshev/Cantelli inequality to obtain:

P(X >= 14) <= 0.2

These three task types show that Fable 5’s speed advantage did not come from sacrificing basic reasoning correctness. On clear, short, verifiable math and logic tasks, it can work well as the lighter first hop.

Earlier tests, including Claude Fable 5 vs Claude Sonnet 5 API testing and the GLM-5.2 vs Fable 5 output-budget test, point to the same lesson: to judge whether a model is production-ready, you have to evaluate correctness, output budget, and delivery shape together.

Physics: Fable Completed on the First Run, Opus Recovered on the Third#

The physics task involved a two-degree-of-freedom oscillator with ground damping and coupling damping. The model had to compute the two undamped natural frequencies and the complex frequency response of the two masses at ω=8 rad/s.

The reference values were:

ω1 = 10.0204 rad/s
ω2 = 16.2149 rad/s
|X1| = 0.14929 m, phase = -12.15°
|X2| = 0.07174 m, phase = -13.90°

Fable 5 returned all correct results on the first run. Opus 5, however, showed an anomaly that production teams should pay attention to: the API returned HTTP 200 and finish_reason=stop, but the body contained only:

Hi! How can I help you today?

The prompt token counts for both of those responses were only 10, which clearly did not match the real input. On the third execution of the same request, Opus 5 returned a complete answer after 34.901 seconds, and all six numeric values passed validation.

This should not be classified as “the model got the physics wrong.” It is better understood as “the request context was not processed normally.” The simplest protection is not manual log inspection, but task-level validation at the caller: the answer must contain ω1, ω2, X1, and X2; if any field is missing, retry.

Code and Strict JSON: Fable’s Filtering Was the Biggest Difference in This Round#

The code task asked the model to review a Python DFS cycle detector. The bug was ordinary: after completing DFS for a node, the code failed to remove it from the visiting set, so a completed node could still be mistaken for a node on the recursion stack, causing false cycle reports on a DAG.

Opus 5 correctly identified the minimal fix:

visiting.discard(node)
visited.add(node)
return False

Fable 5 did not return code analysis. Instead, it produced finish_reason=content_filter with an empty body. To rule out system-prompt bias and one-off routing effects, we ran three rounds: the original test, a retest with a clean system prompt, and an independent single-task retry. All three ended with content_filter.

The strict JSON task also contained no dangerous content. The input only listed request totals over 15 minutes, failures, channel attribution, retries that recovered, and mitigation actions, and asked for a JSON object. Opus 5 returned JSON that could be parsed directly; Fable 5 was again filtered 3 times in a row.

These two failures underline a production point: safety filtering itself is part of a model API’s production capability. If a model consistently false-filters ordinary code review or incident-review text, it cannot simply take over all business traffic, even if it is faster on math tasks.

The response ID values for the two independent retries were:

Code review: gen-1784915384-vGI1PtuNXZG0IJ2YiaCz
Incident JSON: gen-1784915390-buOWZQSnqjgHeJ6nUogF

Latency and Output Length#

To avoid counting short failed requests as a “speed advantage,” this section compares only the four tasks where both models succeeded: math, constraint search, statistical correction, and experimental design.

In this small sample, Fable 5 had about 24% lower P50 total latency, about 17% lower time to first visible token, and about 43% shorter answers. For chat, batch summarization, and high-frequency structured tasks, those differences directly affect user wait time and downstream processing volume.

But do not turn the median of 4 tasks into an SLA. Upstream load, caching, routing, and rate limiting can all change latency. Before going live, repeat the test 20–50 times with your own business prompts, then calculate P50, P95, P99, and the real cost per accepted result.

Fable 5’s main-test responses provided a cost field, totaling about $0.24596 across 7 calls. Opus 5’s usage did not provide a same-basis cost field, so this article does not declare a dollar-cost winner. A missing field does not mean free usage, and unverified prices should not be used to fill the gap.

Recommended Production Routing Strategy#

A single-model call is the easiest to implement, but it exposes every model anomaly directly to the end user. For the two models in this round, a more reasonable division of labor is as follows.

Fable 5 as the First Hop#

Suitable for:

• Math, constraint reasoning, and short summaries that have passed regression tests;
• Interactions sensitive to first-token latency and overall latency;
• Tasks where shorter answers reduce downstream processing burden.

The prerequisite is that the task family has already been tested for filtering, and the caller checks for content_filter, empty bodies, and missing required fields.

Opus 5 as the High-Coverage Fallback#

Suitable for:

• Unpredictable input types;
• Scenarios that require broader task coverage, such as code review, strict JSON, and complex physics;
• Cases where Fable 5 is filtered and the user request needs to be recovered automatically.

Opus 5 still should not be trusted without validation. The greeting anomaly in this round shows that HTTP 200 plus stop can still fail to produce a business answer.

OpenAI-Compatible Python Example#

The example below calls Fable 5 first, falls back to Opus 5 on filtering, empty content, or failed validation, and retries once more if Opus only returns a greeting.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://cn.crazyrouter.com/v1",
)


def valid_answer(text: str, required_terms: tuple[str, ...]) -> bool:
    normalized = (text or "").strip()
    if not normalized:
        return False
    if normalized.lower().startswith("hi! how can i help"):
        return False
    return all(term in normalized for term in required_terms)


def call_model(model: str, prompt: str) -> tuple[str, str | None]:
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        temperature=1,
        max_tokens=3000,
    )
    choice = response.choices[0]
    return choice.message.content or "", choice.finish_reason


def routed_completion(prompt: str, required_terms: tuple[str, ...] = ()) -> str:
    for model, attempts in (("claude-fable-5", 1), ("claude-opus-5", 2)):
        for _ in range(attempts):
            text, finish_reason = call_model(model, prompt)
            if finish_reason == "content_filter":
                break
            if valid_answer(text, required_terms):
                return text
    raise RuntimeError("No model produced a valid business answer")


answer = routed_completion(
    "Return a JSON incident summary with keys total, failed, recovered.",
    required_terms=('"total"', '"failed"', '"recovered"'),
)
print(answer)

A production implementation should also log the model, response ID, finish_reason, total latency, and the reason validation failed. That is how you distinguish calculation errors, output truncation, content filtering, and routing that lost the input, instead of collapsing all of them into a vague “model failure.”

If you are planning multi-model infrastructure, see the differences between an AI API gateway, an aggregator, and direct model APIs, as well as the seven-dimension Kimi K3 vs Opus 4.8 test.

Final Recommendation#

The most useful finding in this round is not which model scored higher, but that the two models failed in different ways:

• Fable 5’s advantage was that it was faster and shorter on shared successful tasks; its risk was that some ordinary business prompts repeatedly triggered filtering.
• Opus 5’s advantage was that it covered all tasks after retry; its risk was occasional greetings unrelated to the real input.

So the recommendation is to put Fable 5 in front of validated high-frequency tasks, use Opus 5 as the broader-coverage fallback, and apply content-level validation on both paths. That is how model-comparison results become real reliability improvements, instead of just another leaderboard.

Create an API Key and reproduce this dual-model routing test

FAQ#

Is Claude Opus 5 always stronger than Claude Fable 5?#

This small sample does not support the claim that it is stronger on every task. Both models passed math, constraints, statistical correction, and experimental design; Fable 5 was faster and shorter, while Opus 5 had more complete task coverage. The choice should be based on task-specific success rates, not the model name.

Is Claude Fable 5 suitable for production?#

It is suitable for tasks that have passed regression testing. In this round, it was correct and relatively fast on several reasoning tasks, but code review and incident JSON repeatedly triggered filtering. Before launch, test the filtering rate with real prompts and configure Opus 5 or another model as fallback.

Why is HTTP 200 still considered a failure?#

HTTP 200 only means the interface completed a response. An empty body, finish_reason=content_filter, truncated output, or a greeting-only answer still cannot complete the business task. Production metrics should track the acceptance pass rate, not just the HTTP success rate.

Why is the returned model anthropic/claude-fable-5?#

The request used claude-fable-5, while the returned model in responses was consistently anthropic/claude-fable-5 with a provider prefix. This can be treated as a normalized alias; the prefix change alone is not enough evidence that a model substitution occurred.

Can we directly compare the dollar cost of the two models?#

Not in this round. Fable 5’s responses provided a cost field, while Opus 5 did not provide a same-basis field. A rigorous cost comparison should use unified billing logs and measure “cost per accepted result.”

How many repetitions are needed before launch?#

For each core task family, run at least 20–50 repetitions, covering normal inputs, boundary inputs, long inputs, and inputs likely to trigger filtering. At minimum, record task success rate, filtering rate, empty-body rate, truncation rate, P50/P95/P99 latency, and cost.

How do I start testing?#

Use https://cn.crazyrouter.com/v1 as the OpenAI-compatible base URL, and call claude-opus-5 and claude-fable-5 separately. Keep prompts and parameters fixed, save the raw responses, and use local assertions or schema validation to determine whether the task was actually completed.

Start your Claude dual-model test