No. 28 Tuesday 10 November Game dev, software and AI

A new top model, and a dial to set

Claude Fable 5.2 tops an independent index and costs less per token, but the bill per task depends on how hard you ask it to think. Plus an overnight game build, GDScript compiled to C++, and what an AI party game really costs.

The short version

  • Software and AI Claude Fable 5.2 is out at $8 in and $40 out per million tokens, 20% below Fable 5.1, and leads Artificial Analysis's index at 65.
  • Software and AI Effort now matters more than the model name: at max effort the index run cost $26.54 per task, and Simon Willison saw max burn 128,000 thinking tokens with no answer.
  • Software and AI Fable 5.2 checks that earlier turns were not edited: change the system prompt, tools or an old message and send back later thinking, and the call fails.
  • Games and software One developer had Fable 5.2 grow a one-hero prototype into a 12-stage, 18-fighter, four-player beat 'em up overnight, then test every stage in a headless browser.
  • Game dev Grit compiles GDScript to C++ at export: up to 49 times faster on typed loops, no gain on engine-bound code.
Software and AI Release

Pick the effort, not just the model

Anthropic released Claude Fable 5.2, its strongest generally available model, at a lower price per token. How much thinking you ask for now decides most of the cost and the wait.

ContextFable is Anthropic's top tier above Opus; Mythos 5.2 is the same model with fewer safeguards, offered only to vetted organizations.

The five effort levels on Fable 5.2, with Anthropic's guidance for each.

Fable 5.2 arrived on November 9 on the Claude API, the major clouds, GitHub Copilot and Vercel's AI Gateway. It costs $8 per million input tokens and $40 per million output, down from $10 and $50 for Fable 5.1, with a 1M token context window and up to 128k output tokens.

Every request runs at one of five effort levels, from low to max. Anthropic's docs say most of the gain already arrives at high, the API default; Claude's apps and Claude Code default to medium. Anthropic reports that Fable 5.2 at high roughly matched Opus 5.5 at max on its FrontierCode coding test at about half the cost per task (a vendor result).

The independent numbers show the other side. Artificial Analysis ranks Fable 5.2 first of 74 models with an index score of 65, run at max effort, but that run used 275M output tokens and cost $26.54 per task, against $10.04 for Opus 5.5. Simon Willison ran the same prompt at all five levels: xhigh gave the best result, and max spent its whole 128,000-token thinking budget and returned nothing.

65Artificial Analysis index at max effort, first of 74 models

Technical details

The API model id is claude-fable-5-2. Effort is set with output_config.effort in the Messages API; the docs say to set a large max_tokens at high and above because thinking counts toward it, and to run your own sweep rather than carry over Fable 5.1 settings. A per-message effort change (beta) keeps the prompt cache.

Fast mode generates output up to 2.5 times faster for twice the price ($16 in, $80 out per million), set with speed: "fast". Anthropic also describes two team roles: Haiku, Sonnet or Opus can consult Fable 5.2 as an advisor on hard steps, and Fable 5.2 can act as an orchestrator that hands simple work to smaller models.

Artificial Analysis measured 98 output tokens per second and 216 seconds to the first answer token at max effort. Vendor-reported scores against Opus 5.5 include 69.9% vs 62.3% on FrontierSWE v2 and 51.4% vs 42.5% on AutomationBench.

Why it mattersA cheaper price per token can still mean a bigger bill if the model thinks longer. Teams that measure effort per task will get the gains; teams that pin max will pay for them twice.

For youDo the Fable effort sweep on one real plugin bug and one SaaS ticket before switching any routine; keep the daily routines on the cheapest level that passes.

effort
A setting that tells the model how much to think before it answers: more effort means more tokens, more time and more cost.
tokens
The small chunks of text a model reads and writes; providers bill by the million.
context window
How much text the model can take in at once, counted in tokens.
Artificial Analysis
An independent group that runs the same set of tests on many models and publishes scores, speeds and costs.

Sources Anthropic: Claude Fable 5.2 and Mythos 5.2Claude docs: EffortArtificial Analysis: Claude Fable 5.2Simon Willison: llm-anthropic 0.31

More like this Less like this

Moving to Fable 5.2

What the new model costs per task, and two changes that can break existing code.

Software and AI Lesson

Cheaper per token, hungrier per task

Fable 5.2 costs a fifth less per token than Fable 5.1, but on the same independent test it wrote far more and cost twice as much per task.

Fable 5.1 against Fable 5.2, from Anthropic's release notes and Artificial Analysis (both index runs at max effort):

Fable 5.1 Fable 5.2
Price per million tokens $10 in, $50 out $8 in, $40 out
Artificial Analysis index 49 65, first of 74 models
Output tokens for the index run 163M 275M
Cost per index task $12.99 $26.54
In Claude Code Saved picks move to the new model Default Fable model from v2.1.321
Zero data retention Not offered Not offered unless Anthropic authorizes it

The new model is smarter and cheaper per token, but it spends more tokens when left at max. Price a real task at two or three effort levels before you move a workload.

Why it mattersPer-token prices are the number on the launch page; cost per finished task is the number on your invoice, and here they move in opposite directions.

For youIf any client SaaS account runs with zero data retention, Fable 5.2 calls will fail there; keep those on Opus 5.5.

zero data retention
An agreement under which the provider keeps no copy of your prompts and answers after replying.

Sources Claude platform release notesArtificial Analysis: Claude Fable 5.2Artificial Analysis: Claude Fable 5.1Claude Code v2.1.321 release

More like this Less like this

Software and AI Do this

Edit the past and the call fails

Fable 5.2 refuses a request that sends back its earlier reasoning after the conversation before it was changed. Agent loops that rewrite their prompt or tools between turns need checking before the switch.

When a model thinks, the API returns that reasoning as a thinking block, and agent code often sends it back on the next turn. For Fable 5.2 and Mythos 5.2, Anthropic now checks every account for one thing: that everything before a returned thinking block is unchanged.

If your code edits the system prompt, the tool list or an earlier message, and then sends back a Fable 5.2 thinking block from a later turn, the request returns a 400 error. Moving a conversation onto Fable 5.2 keeps reasoning from Opus, Sonnet and Haiku 5.5; moving it off drops Fable's thinking blocks, and the call still works.

  • Thinking blocks only work in the account that made them, or a linked one.
  • Computer use needs the newer computer_toolset_20260801; the old tool returns a 400 outside Bedrock.
  • A Fable 5.2 executor accepts only Fable 5.2 or Mythos 5.2 as its advisor.

Why it mattersMany agent frameworks trim history or swap tools between turns to save context. With this model, that habit turns into hard failures.

For youCheck any custom loop that compacts history or swaps MCP tools mid-run before pointing it at Fable 5.2.

thinking block
The part of a reply that holds the model's step-by-step reasoning, kept separate from the answer.
400 error
An HTTP response meaning the server rejected the request as malformed or not allowed.
system prompt
The standing instructions sent at the top of every request in a conversation.

Sources Claude platform release notes

More like this Less like this

Software and AI Do this

Give the new model somewhere to fall back

Vercel added Fable 5.2 to its AI Gateway with a list of backup models, because the model's safety filter can decline some security-flavoured prompts.

Vercel's example: ask for Fable 5.2 at high effort, and name the models to try in order if the request is declined.

import { streamText } from 'ai';

const result = streamText({
  model: 'anthropic/claude-fable-5.2',
  reasoning: 'high',
  prompt: 'Review this login handler for security bugs.',
  providerOptions: {
    gateway: {
      models: [
        'anthropic/claude-opus-5.5',
        'anthropic/claude-sonnet-5.5',
      ],
    },
  },
});

The gateway tries each model in the models list in order when Fable 5.2's cybersecurity classifier declines a request.

Teams with zero data retention switched on get an error instead: Fable 5.2 requires 30-day retention, and prompts are not used for training.

Why it mattersA code-review prompt about security bugs is exactly the kind a safety filter can stop. A fallback list keeps the feature working when that happens.

For youCopy this fallback pattern into any SaaS feature that reviews code or auth flows with the strongest model.

AI Gateway
Vercel's service that sits between your app and many model providers, so one API reaches all of them.
classifier
A small model that screens requests and blocks ones that look like a given category, here cybersecurity misuse.

Sources Vercel: Claude Fable 5.2 on AI Gateway

More like this Less like this

In your tools this week

Claude Code's new default, and the price of speed.

Software and AI Release

Claude Code 2.1.321: the new default and four changes to check

The latest Claude Code makes Fable 5.2 the default Fable model and changes how mods, fast mode and hooks behave.

From the 2.1.321 and 2.1.322 release notes:

  • Fable 5.2 is the default Fable model

    Saved Fable 5.1 picks move to fable; type /model claude-fable-5-1 to go back. Cache reads cost $0.20 per million tokens.

  • Fast mode no longer stalls

    When fast serving is rate-limited or failing, it now tries standard speed on the same model first, instead of losing replies or retrying for minutes. 2.1.322 adds fast mode on Vertex.

  • Mods Claude writes turn on by themselves

    In auto and bypass modes, mods Claude writes are enabled without asking, and their own tool calls raise no prompt. Deny rules and organization policy still apply.

  • Hook and security fixes

    A PreToolUse ask is no longer lost when another hook's defer finishes first, and MCP sign-in no longer sends refresh tokens to another host on a redirect.

Why it mattersA default model change moves every saved session to a new price and behaviour at once; it is worth knowing which model your routines now call.

For youCheck which model the scheduled routines now resolve to after the update, and re-test any hook that returns ask or defer.

mods
Small extensions Claude Code can write for itself, such as panels, commands or hooks on tool calls.
hook
A script that runs automatically at a set moment, such as before a tool runs, and can allow, block or question it.

Sources Claude Code v2.1.321 releaseClaude Code v2.1.322 release

More like this Less like this

Software and AI Release

Fast mode: pay double, wait less

Fable 5.2 has an optional fast mode that writes its answer much faster at twice the normal price.

2.5xfaster output, at most

2xthe price: $16 in, $80 out per million

Set speed: "fast" on an API request, no beta header needed, or toggle it in Claude Code.

Why it mattersFor a developer waiting at the keyboard, speed can be worth more than tokens; for overnight jobs it rarely is.

Sources Claude platform release notes

More like this Less like this

Games made and run with models

An overnight build, the real bill for AI players, and scripts compiled for speed.

Games and software Lesson

A nephew's drawings, a beat 'em up by morning

ContextThe first version, built in June with Claude Code, had one hero and was not worth playing for more than a couple of minutes, the author writes.

A developer left Fable 5.2 working overnight on a small browser game built from his nephew's drawings. By morning it had 12 boss stages, 18 fighters and four-player controller support.

A pixel-art character select screen titled Choose your fighter, with eighteen portraits including children, adults, a dog and two turtles, and four player slots.
Image: Lex Toumbourou, Aiden's Revenge

How Lex Toumbourou's build went, in his own account:

  1. Scan the design

    The nephew's drawings of heroes and twelve numbered villains were scanned and handed over as the reference for every character.

  2. Write one long brief

    A modern take on arcade brawlers, as fun as possible, four-player controllers, its own judgment, and "commit as you go". By morning most earlier code had been rewritten.

  3. Generate the assets

    Images came from OpenAI's image model and sound, music and announcer lines from ElevenLabs, through API keys in the brief.

  4. Test it with a bot

    The agent ran the game through all twelve stages in a headless browser and checked screenshots for problems.

  5. Playtest with the family

    Four controllers over Bluetooth on one laptop. Gaps surfaced, like a power-up move a child wanted, and were added after.

Technical details

The author's tally over two days: about 600 Claude requests, roughly 320M tokens read from cache, 19M written to cache and 1M output, "call it 340M tokens". He never tried the same brief on Opus 5.5, so he does not know whether earlier models could have done it.

Why it mattersThe reusable part is not the one-shot: it is the brief that hands over the design and the self-play bot that checks every stage, which works with any model.

For youThe self-play screenshot bot fits the browser games directly; see today's Try this.

headless browser
A web browser that runs without a window, so a program can load and play pages and take screenshots.
cache
Saved earlier input the model can reuse cheaply instead of reading it again at full price.

Sources Lex Toumbourou: Fable 5.2 one-shotted my nephew's dream gamePlay Aiden's Revenge

More like this Less like this

Game dev Lesson

What one AI player's turn really costs

A developer who runs a Werewolf party game with AI players published the real bill from 51,000 model calls. The same turn cost from a fifth of a cent to over ten cents depending on the model.

Cost of one bot turn in AI Werewolf, by model, from 53 days of real games:

Fable 5.1 is approximate in the source. A typical game of 50 or more turns cost $1.49: $1.03 text, $0.32 images, $0.13 voice. Only 29% of input tokens came from the prompt cache, because bots waited a median of four minutes between calls.

Technical details

With bots calling every four minutes or so, the five-minute cache often expired. On Sonnet 5.5 the one-hour cache cost 3.13 cents per turn against 2.94 cents with no cache. The author's own cost tracking was off by 1.54 times because it priced one-hour cache writes at half their real price; the provider balance falling faster than predicted gave it away.

Why it mattersReal per-turn numbers for AI characters are rare. They show the model choice swings cost by 50 times, and that caching only pays when calls come close together.

For youUse these bands to budget any AI-driven NPC or narrator in the browser games, and reconcile logged token cost against the provider balance in week one.

prompt cache
A provider feature that bills repeated input at a discount if it is sent again within a set time.

Sources Aliaksei Zelianouski: What it costs to run a text game with LLMs

More like this Less like this

Game dev Release

GDScript compiled to C++: fast loops, same engine calls

ContextGodot games are usually scripted in GDScript, which runs in an interpreter; Unity does a similar trick for C# with IL2CPP.

Grit, an experimental tool, turns a Godot game's scripts into C++ when you export it. Math-heavy code runs up to 49 times faster; code that mostly calls the engine barely changes.

Speed-up over Godot's normal script interpreter in the author's benchmarks, same build:

String building gained nothing (1.0 times). Measured by the author on one Ryzen 9 7950X3D under Linux. Grit needs a patched Godot 4.7.2 and custom export templates, is tested only on Linux and Windows x86_64, and its README says not to ship games with it yet.

Technical details

At export, Grit records the bytecode Godot generates, emits C++ into .godot/grit/generated and compiles a custom template. Functions it cannot handle, edited scripts and mismatched signatures fall back to the interpreter one function at a time. The editor always uses the interpreter. The author reports all 1,540 functions in Godot's script test suite compile and pass.

Why it mattersIt shows how much speed is left in a scripting language when you compile ahead of time with a safe fallback, and where it is not: engine calls dominate most game code.

GDScript
Godot's own scripting language, similar to Python, normally run by an interpreter.
export template
The prebuilt engine binary Godot packs your game into when you export it.

Sources Grit on GitHubGameFromScratch: Grit

More like this Less like this

Engine watch

Releases and a mood shift around the engines.

Game dev Release

Engine notes: Godot nears 4.8, Luanti locks its sandbox

Three tool releases from the weekend: a near-final Godot beta, a voxel engine closing a security switch, and a debugger that sees CPU and GPU together.

  • Godot 4.8 beta 3

    74 fixes from 51 contributors, mostly regressions. The .NET build now needs .NET 10 or newer, and a threading race and Web audio bugs are fixed.

  • Luanti 5.18

    Several texture packs can load at once, mods get a Lua lighting API, and the mod security toggle is gone: the sandbox can only be turned off with a command-line flag.

  • One debugger for CPU and GPU code

    Meta extended LLDB so the CPU and GPU show up as two targets in one session, live or from a crash dump. Most of the framework is already in LLVM.

Why it mattersBeta 3 is usually the last big step before a Godot release candidate, and the .NET 10 requirement is the one change that can break a C# project.

LLDB
The debugger from the LLVM compiler project, used to pause a running program and inspect it.
sandbox
A fenced-off environment that limits what code, here a mod, can touch on your machine.

Sources Godot: Dev snapshot 4.8 beta 3Luanti 5.18.0 releasedMeta Engineering: LLDB across CPUs and GPUs

More like this Less like this

Game dev Trend

An engine as a hedge

After a report that investors were in talks to buy Unity, a game designer and teacher started moving a project to Godot.

I've been porting my current project to Godot and I'm really impressed.

Molleindustria, game designer, on Bluesky

The post replies to news, cited from Reuters, that EA owner Silver Lake and Saudi Arabia's PIF had held talks to buy Unity. The author adds that they plan to teach Godot in their classes too.

Why it mattersOwnership news moves engine choices before any terms change; an open source engine is the hedge people reach for.

Sources Molleindustria on Bluesky

More like this Less like this

Learn one thing

What does a model's effort level change?

It sets how much the model reasons before it answers. Higher effort means longer hidden reasoning, which can raise quality on hard tasks but costs more tokens and time.

Think of it like thisIt is like telling a contractor how long to plan before building: a shelf needs a minute, a staircase an afternoon, and planning a shelf for a day only costs you the day.

Reasoning models write out their working before the final answer. That working is billed as output tokens, the most expensive kind, and it also adds wait. An effort level is a budget hint: low keeps the working short, max lets it run as long as it likes.

More effort helps only up to a point. Anthropic's docs say most of Fable 5.2's gain arrives at high, and today's independent numbers show a max-effort run costing twice its predecessor's per task. At the extreme, a model can spend its whole thinking budget and return nothing.

The practical habit is a sweep: run a few real tasks at two or three levels, note pass or fail, time and tokens, and pick the cheapest level that still passes. Re-run it when the model changes.

Effort controls the middle step, which is where most of the cost and time goes.
reasoning model
A model that writes out intermediate thinking before giving its final answer.
output tokens
The tokens a model writes, usually priced several times higher than the tokens it reads.

Try this today

Game dev 45 minutes For practitioners

Have an agent play every level of your browser game and screenshot it

Get a repeatable bot that loads your game headless, plays through each level and flags anything that looks broken, the check that caught problems in today's overnight build.

You needA browser game that runs from a local server, Node.js, and a coding agent such as Claude Code.

  1. Ask for a player script

    Have the agent write a Playwright script that starts the game headless, jumps to each level in turn (add a debug query parameter if needed) and plays with simple inputs for 20 to 30 seconds.

  2. Capture at fixed moments

    Save a screenshot every few seconds and at each level end, named by level and time, plus any console errors.

  3. Let the agent look

    Ask the agent to open the screenshots and the error log and list anything wrong: missing sprites, stuck players, overlapping text, blank screens.

  4. Fix and rerun

    Fix one issue, rerun the script, and commit the script so every later change can be checked the same way.

You know it worked whenThe script reaches every level without hanging, writes a folder of screenshots, and the agent's review names at least one real problem you can see in an image.

For youStart with the three.js prototype that has the most levels; the same script can run before every deploy.

Playwright
A library that drives a real browser from code: it clicks, types, presses keys and takes screenshots.

Sparks

What is catching on right now, and the idea worth borrowing from each.

The lab

Research from the front line, in plain words: what it solves, how, and what you could do with it.

Software and AI PreprintarXiv preprint

Self-tuned agent setups win new tasks but quietly lose old ones

Beneath the Surface: What We Overlook When We Talk About Agent EvolutionX. Wang, Z. Wang, S. Ye, et al.

A diagram of a loop of record, select, rollout, analyze, mutate, validate, evaluation and gate steps, beside three research questions on what improves, where gains hold and how they arise.
Image: Wang et al., arXiv
The problem
Methods that automatically rewrite an agent's prompts, tools and scaffolding are judged by their headline score. Nobody checks what the evolved agent stopped being able to do, or what it costs to run.
The idea
Run four evolution methods on two benchmarks with two agent harnesses, and track every task gained and lost against the starting agent, plus running cost. Then add a gate that rejects changes which lose tasks the agent already solved.
The result
All 16 evolved agents gained tasks and all lost some; most reliability gains also raised cost. With the gate, average success rose by 3.5 to 7.9 points over the seed in all four settings, losing 1 to 5 tasks against 3 to 15 gained.
Use it
If you tune an agent's instruction file, skills or hooks in a loop, keep a set of tasks that already pass and reject any change that breaks one, even when the total score goes up.

For youBefore letting any routine rewrite its own prompt or skills, keep a small regression set of tasks it already handles.

More like this Less like this

  1. Idea
  2. Prototype
  3. Code released
  4. Shipping

ReadPaper (arXiv)Full text (HTML)

Software and AI PreprintarXiv preprint

Where you put a tool error decides whether the agent retries or gives up

Same Error, Different Recovery: How Delivery Changes LLM Agent BehaviorS. Woo, J. Conde, P. Reviriego

Three heatmaps of decision accuracy for eight open models across four delivery conditions, for transient, fixable and unrecoverable faults.
Image: Woo, Conde and Reviriego, arXiv
The problem
When a tool call fails, agent code passes the error back in different ways. It was unclear whether the placement matters, or only the error text.
The idea
Test 13 open models on the same failures delivered different ways. The best form keeps the failed call in the history and adds a short new note naming the kind of fault (transient, fixable, unrecoverable) and what to do.
The result
On explicit errors, success rose 14.2 points for 7 to 8B models and 10.5 for 32 to 70B, with no change on runs without faults. Removing the failed exchange from history made some models stop dead.
Use it
In your own tool loops or MCP clients, never delete a failed call; append a one-line note saying whether a retry is safe, and only retry tools that do not change anything.

For youApply the note pattern to the MCP servers that wrap build and deploy steps, where blind retries would be dangerous.

More like this Less like this

  1. Idea
  2. Prototype
  3. Code released
  4. Shipping

ReadPaper (arXiv)Full text (HTML)

Also moving

This week on Toa Radar

Read the weekly summary: The week the checks moved outside the agent
Tune mode is on in this browser. Turn it off