Coding Agent Index v2.1: Fable 5.2 vs Opus 5.5 Effort

Artificial Analysis Coding Agent Index v2.1 puts Claude Fable 5.2 high and xhigh alongside Opus 5.5 max at 58. Fable max falls to 56 while costing $44.22 per task, versus $7.51 at high. Understand the tougher FrontierCode-AA 2.0 benchmark, timeouts, safety fallbacks, and how to choose effort for pay-as-you-go coding.

Contents
Coding Agent Index v2.1: Fable 5.2 vs Opus 5.5 Effort

For Claude Fable 5.2 coding agents, start at high effort rather than max. In Artificial Analysis Coding Agent Index v2.1, Fable 5.2 scores 58 at high and xhigh, while max falls to 56 and costs $44.22 per task instead of $7.51. Claude Opus 5.5 at max also scores 58, but its strengths differ across the underlying benchmarks.

The November 14, 2026 release provides a useful reason to rethink effort defaults. Higher effort can consume enough extra time and output tokens to reduce completed-task performance.

These are benchmark results for specific models, agent harnesses, settings, and task limits. They are not guaranteed success rates for production coding work.

What changed in Coding Agent Index v2.1?

Version 2.1 makes repository engineering harder to pass, updates terminal-task verification, and changes how API costs account for caching.

Artificial Analysis now combines three evaluations:

ComponentTasksWhat it measuresv2.1 change
FrontierCode-AA 2.0132Repository changes that meet maintainer merge standardsReplaces FrontierCode 1.1
Terminal-Bench 4.166Agentic terminal workflowsSame tasks, updated verifiers
SWE-Atlas-QnA-AA124Understanding and explaining repository behaviorRetained from v2.0

The official methodology gives each benchmark one-third of the final Index. It runs three attempts per task, averages those attempts, and then averages tasks within each benchmark.

Therefore, the 66 terminal tasks contribute as much to the Index as the 132 engineering tasks.

FrontierCode-AA 2.0 explains the score drop

The new FrontierCode component uses Artificial Analysis’s implementation of Cognition’s FrontierCode 2.0.

It expands the previous 100-task evaluation to 132 tasks. The scoring still asks whether a repository maintainer would accept the change.

However, the new tasks demand more extensive implementation work.

Cognition’s FrontierCode 2.0 announcement reports that reference solutions modify 67% more files and 89% more lines on average. It also reports 43% more blocking criteria.

Blocking criteria cover requirements that a change must satisfy to receive credit. Failing any blocking criterion produces a zero score.

This matters for coding agents that produce a plausible patch but miss a regression, incomplete fix, or repository convention.

In its November 14 announcement, Artificial Analysis reported:

  • All 23 configurations evaluated on both FrontierCode versions scored lower on the new task set.
  • Their mean FrontierCode score fell from 45% to 29%.
  • The overall Index fell by approximately five points on average.

Those results describe a changed evaluation, not evidence that the same models suddenly became less capable.

The 16-point FrontierCode decline alone corresponds to about 5.3 points in an equally weighted three-component Index. This arithmetic explains most of the reported average decline.

Do not compare a v2.0 score directly with a v2.1 score when choosing a model.

Also distinguish FrontierCode-AA 2.0 from Cognition’s standalone results or Artificial Analysis’s Intelligence Index. They use different agent harnesses, so matching task names does not make the scores interchangeable.

Terminal-Bench 4.1 changes verification, not the tasks

Terminal-Bench 4.1 retains the 66 tasks from version 4.0.

The changes focus on verifying agent output correctly and resisting reward hacking. Reward hacking means obtaining benchmark credit without completing the intended work.

The Terminal-Bench team’s release notes document stronger isolation for agent-written code and fixes for false-negative verifier results.

In version 4.1, verification can run submitted code as an untrusted user in a separate process. This prevents that code from directly reading protected tests or modifying the reward file.

The release also corrects overly restrictive verifier assumptions. For example, the freecad-platform-drawing verifier now accepts valid solutions built from native 3D primitives instead of requiring extruded 2D sketches.

Artificial Analysis reported that every one of the 23 configurations tested on both versions moved by less than three points on Terminal-Bench.

That makes FrontierCode the main explanation for the new Index’s lower scores.

Version 2.1 also changes the Index’s API-cost calculation. Its version history explicitly records alignment with the Artificial Analysis Intelligence Index methodology.

The updated calculation combines provider-reported token counts with live measurements of each model’s typical cache-hit rate. It also includes cache-write charges when providers bill for creating prompt cache state.

This differs from relying on the cache-hit rate measured during one benchmark run. A provider route with different cache behavior can produce a different bill.

Fable 5.2 high vs xhigh vs max: what do you buy?

high is the best starting point for Fable 5.2 if you want strong coding results without paying for unnecessary reasoning.

Artificial Analysis’s Claude Code versus Codex results, checked November 15, report the following Fable 5.2 configurations:

Fable 5.2 effortIndex v2.1API cost/taskAgent time/task
low48$2.4913.4 min
medium53$2.8915.1 min
high58$7.5131.3 min
xhigh58$15.4753.3 min
max56$44.222.2 hours

Costs are average USD pay-per-token API costs for the benchmark workload. They are not subscription charges or estimates for every coding ticket.

The table shows three useful effort decisions.

Choose medium for bounded work. It scores 53 and costs $2.89 per task. That makes it a candidate for small fixes with clear tests, especially when lower spending matters more than maximum first-pass quality.

Choose high for demanding repository changes. It reaches the highest displayed Fable 5.2 Index score at $7.51 per task.

Require evidence before choosing xhigh. It costs approximately 2.06 times as much as high while displaying the same rounded Index score of 58.

Artificial Analysis reports that medium, high, and xhigh all lie on its cost-performance Pareto frontier. The displayed integer tie does not prove identical underlying performance. However, the extra cost at xhigh needs a task-specific benefit.

The biggest difference concerns max:

[ \frac{$44.22}{$7.51}\approx5.89 ]

In this evaluation, max costs approximately 5.9 times high while scoring two Index points lower.

That is an additional $36.71 per benchmark task with no measured aggregate improvement.

Why does Fable 5.2 max score lower?

Artificial Analysis attributes the lower max score mainly to tasks reaching their time limits.

Its effort and timeout breakdown reports:

BenchmarkFable 5.2 xhigh timeout rateFable 5.2 max timeout rate
FrontierCode-AA 2.01%16%
SWE-Atlas-QnA-AA0%13%

These percentages describe timed-out attempts, not overall task failure rates.

The same report says Fable 5.2 at max uses approximately three times as many output tokens per FrontierCode-AA 2.0 task as xhigh.

More reasoning consumes time. If the agent reaches the deadline before completing its work, that attempt scores zero.

This explains how a more expensive setting can produce a lower benchmark result.

It does not establish that max is intrinsically worse on a task with unlimited time. It establishes that max performs worse under the measured workload and time constraints.

For production agents, that distinction matters. A task that exceeds your CI or automation deadline can fail operationally even if the model might eventually produce a stronger patch.

Fable 5.2, Opus 5.5, GPT-6.1 Sol, or Kimi K3.1 Pro?

Choose a configuration by its strongest relevant benchmark and your cost limit. The Index combines different kinds of software engineering work, so a shared total can conceal meaningful differences.

Fable leads repository implementation; Opus leads repository Q&A

Artificial Analysis reports this component breakdown:

ConfigurationFrontierCode-AA 2.0Terminal-Bench 4.1SWE-Atlas-QnA-AAIndex
Claude Code + Fable 5.2 high49%64%62%58
Claude Code + Fable 5.2 xhigh49%64%62%58
Claude Code + Opus 5.5 max44%65%66%58

The numbers favor different uses.

For difficult repository changes, test Fable 5.2 at high first. It leads Opus 5.5 max by five points on FrontierCode-AA 2.0.

For repository investigation and technical explanations, test Opus 5.5 max. It leads Fable 5.2 by four points on SWE-Atlas-QnA-AA.

Terminal-Bench is effectively close for these two configurations, at 64% and 65%.

Opus 5.5 max costs $12.61 per task in the same Coding Agent Index results. It is cheaper than Fable 5.2 xhigh at $15.47, but more expensive than Fable high at $7.51.

Therefore, Opus 5.5 max is a reasonable alternative to Fable xhigh, especially for repository Q&A. Fable high remains the lower-cost first test for merge-ready implementation work.

If you want to compare Opus directly, use the Claude Code Opus 5.5 switching guide to select the intended model rather than relying on an inherited alias.

GPT-6.1 Sol is the low-cost baseline

Codex with GPT-6.1 Sol at max scores 52 and costs $1.51 per task.

Its component scores are:

ComponentGPT-6.1 Sol max
FrontierCode-AA 2.042%
Terminal-Bench 4.154%
SWE-Atlas-QnA-AA60%

Sol does not lead these benchmarks. Its advantage is the combination of useful coding performance and a much lower measured API cost.

For high-volume, verifiable coding tasks, start with Sol when controlling spending matters more than the highest Index score.

Escalate to Fable 5.2 high when you find a task category where Sol produces too many rejected changes or requires excessive review.

The decision should reverse if Fable’s higher initial cost does not improve accepted results enough to justify the difference.

The GPT-6.1 Sol, Astra, and Opus comparison provides additional model-selection context.

Kimi K3.1 Pro leads the terminal component

Kimi Code CLI with Kimi K3.1 Pro reaches 68% on Terminal-Bench 4.1, according to Artificial Analysis’s benchmark-specific results.

That exceeds:

  • Claude Code + Sonnet 5.5 max: 66%
  • Claude Code + Opus 5.5 max: 65%
  • Antigravity CLI + Gemini 4 Carbon high: 65%
  • Claude Code + Fable 5.2 high or xhigh: 64%

However, the overall Kimi Code CLI result is 49, with an average API cost of $2.94 per task.

That means Kimi’s terminal advantage does not extend to the composite Index.

Choose Kimi K3.1 Pro for an initial evaluation of terminal-heavy automation, environment repair, or command-driven workflows. Prefer Fable high for implementation tasks if its higher FrontierCode performance transfers to your repositories.

Use the Kimi K3.1 Pro coding setup guide when configuring the model and its agent harness.

Safety refusals and fallback models change what a score represents

The v2.1 results describe complete agent configurations, including their behavior after safety refusals.

Artificial Analysis’s safety-refusal breakdown reports these fallback-completion rates:

Evaluated configurationAttempts completed by a fallback model
Devin Fusion CLI: Opus 5.5 max + GPT-6 Luna high9%
Claude Code + Opus 5.5 max9%
Claude Code + Fable 5.2 xhigh6%
Claude Code + Sonnet 5.5 max5%

The benchmark also reports that Codex blocks approximately 1% of attempts with GPT-6.1 Sol max and GPT-6 Astra max.

A fallback completion is not necessarily a successful solution. It means another model finished the attempt after the original model refused.

Under the published scoring rules, a fallback-completed attempt receives its normal evaluation score. An attempt that ends blocked receives zero.

This affects interpretation in two ways.

First, Opus 5.5’s score of 58 does not measure isolated Opus responses on every task. Some scored attempts were completed using a fallback model.

Second, the results do not establish what Opus or Fable would have scored with fallback disabled. The percentage of fallback attempts is not the same as their contribution to successful outcomes.

Security-related benchmark tasks can trigger these safety mechanisms. Your production environment may use different fallback behavior, provider policies, or model routes.

When comparing agents, record whether an attempt switched models. Otherwise, a cost or quality difference may reflect routing rather than the model you intended to test.

How to set Claude Code effort and control spending

Use high as the initial Fable 5.2 setting, then change effort only when an identifiable task category justifies it.

Anthropic’s effort documentation confirms that Fable 5.2 supports low, medium, high, xhigh, and max. Its API default is high.

Opus 5.5 also supports all five levels, but its API default is medium.

This is an important comparison condition. The Opus 5.5 max benchmark result does not describe a request that simply uses the default effort.

Set and verify the effort in Claude Code

With Claude Code installed and access to Fable 5.2 configured, open a terminal in your repository.

For Bash:

claude --model claude-fable-5-2 --effort high

In the Claude Code session, run:

/model
/effort

Check that the intended model and effort are active.

Anthropic’s Claude Code effort tutorial documents these interactive commands:

/effort medium
/effort high
/effort xhigh
/effort auto

Use one command at a time. The last command sets the session’s requested effort.

/effort auto resets the effort to the selected model’s default.

For a persistent per-model choice, use /effort in an interactive local session. In Claude Code v2.1.251 or later, the client saves the chosen level under modelSettings in the user settings file, ~/.claude/settings.json.

Do not rely on a top-level effortLevel in that user file to configure Fable 5.2. The Claude Code settings reference states that Opus 5.5 and later models ignore that legacy user-level setting until you save a model-specific level.

You can also use CLAUDE_CODE_EFFORT_LEVEL to set effort through an environment variable. According to the environment-variable reference, it takes precedence over --effort, /effort, modelSettings, and effortLevel.

If /effort or --effort appears ineffective, check whether CLAUDE_CODE_EFFORT_LEVEL is set. Remove that override if you want the interactive or launch setting to take effect.

For ordinary testing, prefer the interactive command or --effort flag. The flag applies for one session; a saved interactive choice can persist into future sessions.

Claude Code makes max session-only unless explicitly set through the environment variable.

Enterprise administrators may also cap available effort levels. An enforced cap can lower the actual effort even when you request a higher level.

For further setup details, see the Claude Fable 5.2 Claude Code and API guide.

Measure the effort level on a real task

Choose a representative repository task with clear acceptance criteria.

For example, ask your agent to inspect a failing parser test, make the smallest correct fix, run the affected tests, and report the files changed.

Start with Fable 5.2 high. Record the final test result, accepted or rejected status, elapsed time, API charges, and any timeout or fallback.

Repeat the task on a clean repository state at medium and xhigh.

Keep the tool permissions, test commands, repository revision, and task deadline consistent.

Evaluate the results using these questions:

  1. Did the change pass the required tests and review?
  2. Did extra effort prevent a rejected change or reduce a retry?
  3. Did the agent finish within the operational deadline?
  4. Did the improvement justify the additional API cost?

For a team with many recurring tasks, use several tasks from each major category rather than relying on a single example.

Calculate total cost per accepted result, including failed attempts and retries. Record human review and infrastructure costs separately from API usage.

This gives you a more useful local decision than dividing a benchmark price by an Index score.

Does the API provider change the recommendation?

The effort recommendation can transfer to another API route, but the published task costs may not.

As of November 15, 2026, BetterToken’s model catalog lists claude-fable-5-2, claude-opus-5-5, gpt-6.1-sol, and kimi-k3.1-pro for pay-as-you-go access.

Its Claude Code integration documentation uses the Anthropic-compatible Base URL https://bettertoken.ai, without /v1.

BetterToken API access is separate from Claude subscriptions. Model routing, cache behavior, and supported features can change the actual spending and observed results.

Verify your endpoint’s effort handling and measure its charges before applying Artificial Analysis’s task-cost numbers to that route.

For a recurring pay-per-token coding workload, the useful starting policy is simple: use Fable 5.2 high for difficult implementation work, reduce effort where acceptance holds, and reserve xhigh for measured gains. Avoid making max a global default based only on its label.

The v2.1 evidence favors completing more accepted work within your time and cost limits, rather than maximizing reasoning effort on every request.

Ready to optimize your LLM workflow?

Join thousands of developers building faster, smarter, and more cost-effective AI applications with BetterToken.

Get Started for Free