# When Fable 5 Is Worth the Premium

Stet publishes a public search API over its indexed pages; the guide is at https://www.stet.sh/agents/agent-access.

Source: https://www.stet.sh/blog/when-fable-5-is-worth-the-premium
Source observed: 2026-11-15T21:03:04.763Z
Last checked: 2026-11-16T02:17:21.084+00:00
Indexed: 2026-11-15T21:06:14.888+00:00

---

# When Fable 5 Is Worth the Premium

**June 14, 2026 · Updated July 1, 2026 · 9 min read**  
[Ben · Founder, Stet](https://www.stet.sh/about)

Fable 5 led our compact local score on a 30-task slice, but the useful decision is task-specific rather than “always use Fable.” We recommend routing to Fable when hidden semantic behavior, parser or planner shape, review risk, or broad scope makes a wrong patch expensive; use cheaper models for narrower, reviewable work.

## Study scope and headline result

We tested Fable 5, Opus 4.8, Opus 4.7, GPT-5.5, and Composer 2.5 on 30 real merged PRs from GraphQL Go Tools and SQLParser Rust. Each task used a frozen repository snapshot in Docker, a prompt, and one attempt. We graded tests, equivalence to the human change, code-review acceptance, footprint, craft, and discipline.

This is a cleaned **n=30** slice: GraphQL Go Tools (Go, n=9) plus SQLParser (Rust, n=21). It is directional local evidence, not a statistically significant global comparison.

| Model | Repo-balanced local score | Cost per task |
| --- | ---: | ---: |
| Fable 5 | 81.7 | $5.29 |
| GPT-5.5 | 73.2 | $3.50 |
| Opus 4.8 | 72.7 | $3.56 |
| Opus 4.7 | 71.0 | $4.93 |
| Composer 2.5 | 68.0 | $0.51 |

Lower cost is better; higher local score is better. Tests were downweighted because every arm cleared 87%+ in this slice. The local score is a compact display score, not a replacement for task-level evidence. Its displayed weights are Tests 5%, Equivalence 30%, Code review 25%, Craft 25%, and Footprint 15%.

## Per-axis comparison

| Axis | Fable 5 | Opus 4.8 | GPT-5.5 | Opus 4.7 | Composer 2.5 |
| --- | ---: | ---: | ---: | ---: | ---: |
| Tests | 30/30 | 28/30 | 29/30 | 28/30 | 28/30 |
| Equivalence | 26/30 | 22/30 | 23/30 | 20/30 | 20/30 |
| Code review | 18/30 | 18/30 | 14/30 | 16/30 | 12/30 |
| Craft mean | 3.24 | 3.12 | 2.93 | 3.09 | 2.76 |
| Footprint | 73.1 | 78.1 | 74.2 | 76.4 | 69.5 |
| Cost/task | $5.29 | $3.56 | $3.50 | $4.93 | $0.51 |
| Total tokens | 3.01M | 3.74M | 4.57M | 6.88M | 2.27M* |
| Input tokens | 2.98M | 3.70M | 4.55M | 6.85M | 2.26M* |
| Output tokens | 32.3K | 45.5K | 14.9K | 33.4K | 13.9K* |
| Tool calls | 25.0 | 70.3 | 84.0 | 66.5 | 96.0 |
| Patch calls | 4.7 | 13.0 | 12.8 | 10.3 | 20.0 |
| Duration | 10.0m | 11.1m | 8.0m | 10.8m | 4.6m |

`*` Composer token telemetry is partial.

## Taskwise comparison: Fable 5 versus Opus 4.8

Behavior mostly drew. Fable had a small equivalence edge and mixed craft results, while Opus retained the footprint and cost advantage.

| Metric | Fable wins | Draws | Fable losses |
| --- | ---: | ---: | ---: |
| Tests | 2 | 28 | 0 |
| Equivalence | 5 | 24 | 1 |
| Code review | 2 | 26 | 2 |
| Clarity | 5 | 22 | 3 |
| Simplicity | 8 | 16 | 6 |
| Coherence | 15 | 13 | 2 |
| Intentionality | 5 | 18 | 7 |
| Robustness | 13 | 11 | 6 |
| Instruction adherence | 9 | 11 | 10 |
| Scope discipline | 11 | 14 | 5 |
| Diff minimality | 10 | 14 | 6 |
| Footprint | 1 | 22 | 7 |
| Cost | 3 | 0 | 27 |
| Input tokens | 21 | 4 | 5 |
| Output tokens | 14 | 9 | 7 |

Binary ties remain draws; craft rows use a 0.25-point draw band on a 0–4 scale; footprint requires material patch-surface separation; cost and token rows require a visible resource gap.

## A task where Fable paid off

### `graphql-go-tools#817`: pub/sub argument-template validation

All three compared arms passed tests, but Fable passed equivalence and review by covering the hidden schema/NATS boundary for pub/sub argument templates in NATS subjects and subscription filters, including nested input-object paths.

The important distinction was rejecting invalid templates, non-leaf paths, and malformed final subjects. Fable validated nested paths against schema fields, required scalar or enum leaves, preserved static subjects, handled multiple placeholders, and rejected malformed NATS subjects. The active criterion was that paths resolve through defined input fields and terminate at scalar or enum leaves. Fable’s recorded task cost was $9.71.

## Five trace reads

### `graphql-go-tools#859`: planner performance

Fable indexed datasource `TypeFields` membership, added-path lookup, and missing-path-by-parent lookup while preserving fallback scans, first-occurrence behavior, remove semantics, nil handling, and duplicate merging. Opus 4.8 used a smaller, cheaper patch but left a scan in the missing-path case and carried stale-index and nil-receiver review risks. Use Opus for a narrow local optimization; test Fable first when lifecycle invariants and performance are coupled.

### `sqlparser-rs#1713`: FROM-first SQL

Fable and Opus 4.8 both passed tests, equivalence, and review. Fable used fewer tokens and had the cleaner parser shape; Opus was cheaper. The task still called for a dialect audit because Fable appeared to enable FROM-first support for `GenericDialect`. Add dialect-negative tests before shipping that kind of change.

### `graphql-go-tools#843`: block-string JSON serialization

GPT-5.5 was the right route. Fable was cheaper and had lower footprint, but failed to recover raw triple-quoted source and retained an escaping path that could emit invalid JSON for multiline strings. GPT-5.5 recognized the representation-layer issue and emitted spec-correct output.

### `sqlparser-rs#2185`: Oracle hierarchical queries

Fable passed equivalence while Opus 4.8 did not, but both failed review. Fable handled `START WITH`, `CONNECT BY`, `NOCYCLE`, and `CONNECT_BY_ROOT` better, yet left `CONNECT BY` too late relative to clauses such as `GROUP BY` and `HAVING`, and could not preserve clause order in the AST/display shape.

### `sqlparser-rs#1472` and `sqlparser-rs#1727`: Composer’s cheap-draft boundary

Composer passed review for $0.22 on the narrow `sqlparser-rs#1472` invariant involving Hive prefix logical NOT and PostgreSQL postfix factorial. On `sqlparser-rs#1727`, Composer passed tests for $0.26 but accepted PostgreSQL-invalid `ALTER TYPE` syntax; Fable cost $3.99 and passed equivalence and review.

## When to route to cheaper models

- **Opus 4.8:** our default for most medium-risk tasks. It cost $3.56/task versus Fable’s $5.29. On `sqlparser-rs#1620`, Opus shipped an equivalent, review-passing SQLite tokenizer dialect opt-in for $0.74 versus Fable’s $1.56, with craft 3.73 versus 3.69.
- **GPT-5.5:** $3.50/task and sometimes the winner. It handled raw-source recovery on `graphql-go-tools#843` and was the cheapest review-clearing patch on `graphql-go-tools#1232`.
- **Composer 2.5:** a $0.51/task cheap-draft route for local, mechanically reviewable invariants; it is not a peer to the frontier.
- **Opus 4.7:** $4.93/task in this slice, with neither enough savings nor enough quality advantage to justify routing to it.

## Routing policy

Start with Opus 4.8 high/xhigh for normal medium-risk engineering: routine parser plumbing, commodity dialect additions, ordinary API additions, and work whose failure modes the tests and review rubric are likely to expose.

Route directly to Fable when a task involves:

- Invalid-input rejection or edge-case semantics
- Parser, planner, public API, or AST shape
- Broad or breaking refactors
- High review cost, where a subtle error would consume senior reviewer time
- Scope-discipline-sensitive work where overgeneralization is risky

## Cost and process

Fable averaged 25.0 tool calls per task, compared with Opus 4.8 at 70.3, GPT-5.5 at 84.0, and Composer at 96.0. Patch calls averaged 4.7 for Fable, 13.0 for Opus 4.8, 12.8 for GPT-5.5, 10.3 for Opus 4.7, and 20.0 for Composer. Fable’s patch-rewrite ratio was 0.49 versus 1.6–2.7 for the field.

Per task, Fable averaged about 2.98M input and 32K output tokens; Opus 4.8 averaged 3.70M and 45.5K; GPT-5.5 averaged 4.55M and 15K; Opus 4.7 averaged 6.85M and 33K. Composer token telemetry is partial.

## What this means

We use this workflow to answer repo-specific questions: whether a model, [AGENTS.md configuration](https://www.stet.sh/instruction-evals), or routing-policy change is safe to roll out. A public leaderboard or another team’s code cannot answer that for your repository. [Get started](https://www.stet.sh/private).

## FAQ

### Did Fable 5 beat Opus 4.8?

Not as a blanket routing rule. Fable led the compact score, 81.7 versus Opus 4.8 at 72.7, but Opus cost $3.56/task versus Fable at $5.29. The taskwise evidence supports paying for Fable on hidden semantic boundaries and planner/parser shape.

### When is Fable 5 worth the premium?

When a task carries above-test risk: invalid-input rejection, parser or planner architecture, public API or AST shape, cross-dialect precedence, broad refactoring, or high review cost. For ordinary medium-risk work, start with Opus 4.8.

### Should every team switch to Fable 5?

No. This is a local two-repository slice, not a global ranking. Default to Opus 4.8, escalate to Fable for above-test risk, and measure the policy on your own repositories.

---

[Read this page’s summary](https://www.stet.sh/agents/api/public/v1/page-tldr?url=https%3A%2F%2Fwww.stet.sh%2Fblog%2Fwhen-fable-5-is-worth-the-premium&trace=t_5da45423e484)

## Ask a follow-up about this page

Need a more specific answer? Ask the exact question you have. It returns a fresh, cited answer from Stet’s knowledge base. No account or API key required.

Open this URL with your own question, URL-encoded. Include your question in q. All research inputs are optional; no account or setup.

`GET https://www.stet.sh/agents/agent/faq?q={question}&trace=t_5da45423e484`

[Tool guide and examples](https://www.stet.sh/agents/agent-access) · [OpenAPI](https://www.stet.sh/agents/api/public/v1/openapi.json) · [Page TLDR form](https://www.stet.sh/agents/agent-tools/page-tldr?url=https%3A%2F%2Fwww.stet.sh%2Fblog%2Fwhen-fable-5-is-worth-the-premium). Opening a form does not execute a tool.