Author’s note: the “AAA visuals” in a 49-second video are actually a self-contained WebGL web page of about 3.6MB. This article explains why a browser can run it, what extra step Fable 5.2 took, and where the roughly $550 bill mostly went.
Three conclusions up front:
- What runs in the browser isn’t a console blockbuster, it’s a self-contained web page. I checked Saltline’s public page on 2026-11-11. It’s about 3.6MB, references no external scripts, and renders through WebGL.
- Fable 5.2’s real skill is finishing the whole page unattended. The official positioning is an agent that can work continuously for hours. The prompt itself limited the scope to “a very small level,” so AAA is the visual goal, not a measured tier.
- Most of the roughly $550 went to the model re-reading what it had already written. Recalculated at the official list prices, the same token count without caching would cost about $3,668.
This isn’t another retelling of “AAA game comes to the browser.” Below, I only cover one chain of events from 2026-11-09: the video posted by TokenGremlin, Saltline by Felix Rieseberg, and the prompt and bill from his own post.
Core value: after reading this, you’ll be able to explain why Saltline plays with a single click, what extra step Fable 5.2 actually took, and which three prices to check first on a long-running task.
Fable 5.2 and Saltline: The Key Facts at a Glance
Most people saw this through a TokenGremlin post, captioned roughly “an Anthropic engineer made this with Fable 5.2, and it’s AAA-level.” TokenGremlin’s bio says they track models, agents, and leaks, and they aren’t an Anthropic employee. The game’s actual author is Anthropic’s Felix Rieseberg, and it’s called Saltline.
| Item | Details | Basis |
|---|---|---|
| Video post | TokenGremlin, 2026-11-09 20:35 UTC, 49-second video | About 1.37 million views when the page was checked on 2026-11-11 |
| Game author | Felix Rieseberg, bio reads “I build things @AnthropicAI” | His own post |
| Collection | Three Games: The Clockmaker’s Heart, Saltline, Tidewright | The collection page footer says “First drafts, no human feedback” |
| Cost | About $550, roughly 2.7M output tokens and 445M input tokens, heavily cached, 8 hours of work | Approximate figures from Felix’s own post |
| Page size | About 3.6MB (3,593,477 bytes), 0 external scripts | Observed on the public page on 2026-11-11 |
| Rendering path | WebGLRenderer, shaders use 300 es (WebGL2) | Same as above; WebGPURenderer count is 0 |
The link TokenGremlin posted repeatedly in their replies points to the Three Games collection. When people asked why they didn’t credit the original author, they replied that they’d posted earlier, that they only reposted a few minutes after Felix’s post, and that “this is a different video.” So the video file isn’t the same one as Felix’s later post, but it shows the same game, Saltline: a container terminal in the rain, gantry cranes, a red-dot crosshair, and the objective in the upper left reading CUT THE THREE UPLINK RELAYS. The recording’s header also carries the label “Content is user-generated and unverified.”
There were other demos the same day, and they shouldn’t be lumped together with this one. Kevin Ngo posted a boat sailing through 8 dream worlds, and according to CellCog’s coverage he mentioned in a reply that he used Tripo 3D and Suno. Sholto Douglas posted an arena shooter with portals, and CellCog says the mechanics, weapons, and levels came from a detailed description he wrote. Of the three, only Felix’s Saltline comes with the prompt, the timing, and the token bill all together.
Saltline in the Video Is Just One Level: How Small Was the Task Fable 5.2 Got?
The gist of Felix’s original post: he had the model build a few games and kept the very first draft of each. The one he liked best was the first-person shooter, Saltline. Later he posted the prompt and added a line: “I’m slowly discovering that the age of prompt engineering is basically over.”
The first half of the prompt is quoted directly from the original: “You know, you should also build me a FPS. Insanely detailed quality pls, something that looks visually like it can keep up with AAA. Make it small in scope (like a tiny level) but”. The second half comes from a quote in CellCog’s 2026-11-10 report: “otherwise impressive photorealistic graphics”. In other words, the prompt itself squeezed the scope down to one tiny level. It asked for something that “looks like it can keep up with AAA,” not for an actual AAA game.
The on-page text matches that scale. The mission briefing reads “Cut three relays and reach the boat. About five minutes.” and the closing line is “Breacher is aboard. Saltline is dark. Good work.” Three relays, one boat, about five minutes: that’s the whole level.
The sound event names include gull and hound (for example gull_fire, hound_servo, relay_cut), but all that tells us is that the enemy types are defined on this page. Felix also mentioned that his claude.md is empty. He didn’t say which tool he used for those 8 hours, or whether effort and fast mode were turned on.
Why a browser can run this 3.6MB Saltline page
Console games need a separate install because their models, textures, and audio often run to tens of GB, and they ship with an entire engine of their own. Saltline takes a different route: the geometry, texture data, and sound all live in a single web page, and the browser uses your graphics card to draw the picture through WebGL. Small level, small data, so an ordinary computer can run it just by opening a link.
| Comparison | This Saltline page | Typical big console game |
|---|---|---|
| Size | About 3.6MB | Often tens of GB |
| How it runs | Click a link, runs right in the browser | Download, install, update |
| Engine | Three.js bundled into the page’s own script | In-house or commercial engine |
| Asset source | Generated inside the page; no GLTFLoader, no models pulled from external addresses | Huge art asset packs |
| Content scale | One level, about five minutes | Multiple levels, open world, or online multiplayer |
| Graphics API | WebGL2 | Native console graphics API |
There’s no WebGPURenderer anywhere in the source, so this page’s rendering path is WebGL, not WebGPU. One caveat: the APIs above are just what matched up when I looked at the source on 2026-11-11. It wasn’t a line-by-line audit.
The visual tricks that make it look AAA
Saltline looks AAA because it uses the same kinds of visual techniques: physically based materials, fog, environment reflections, rain, and a red-dot crosshair. In a small level, these are enough to make a real impact. It has no open world, no 100-player multiplayer, and none of the content volume of a console game.
| Visual technique | What matches in the source | In plain English |
|---|---|---|
| Physically based materials | MeshStandardMaterial, MeshPhysicalMaterial | Metal and wet ground reflect light realistically |
| Fog | FogExp2 | Distant objects fade to gray, so the space feels deeper |
| Environment reflections | PMREM | Surfaces mirror their surroundings |
| Procedural textures | DataTexture | Textures are computed inside the page, with no external images |
| Spatial audio | AudioListener | Sound changes with position |
Some replies said the visuals look like a canal map from a certain shooter. All that shows is that this kind of visual target is easily mistaken for an existing map; it doesn’t mean the level was copied from any particular game. This article also doesn’t cover how to recreate any existing game.
The extra step Fable 5.2 takes: writing a whole page unattended
The magic isn’t that browsers suddenly know how to make games. WebGL has been able to draw these visuals for ages. The change is on the model side: the official positioning for Fable 5.2 is an agent that can keep working for hours at a stretch, aimed at demanding reasoning and long-running tasks. Someone gives it a one-line goal, and it scopes the work, writes the page, and embeds the asset data into the page itself. Felix says nobody gave feedback along the way.
The page kept growing and ended up around 3.6MB. Fable 5.2 has a 1M-token context window, a 128K max output, and a knowledge cutoff of June 2026. That 1M context window is what lets it hold the whole page in view the entire time and check every edit against what it already wrote.
This also explains the oddest ratio on the bill: output was only about 2.7M tokens, while input was about 445M, roughly 165 times the output. Every step re-reads the page that’s already been written, and after enough passes, the input count snowballs.
A few points already got dedicated write-ups that day, so here’s one line on each:
- Fable 5.2 claims output up to 30% faster than 5.1 (official figure).
- Fast mode is the same model, with output up to 2.5x faster (official figure), priced at $16 / $80. Felix didn’t say whether it was on for this run.
- Adaptive thinking can’t be turned off, and the default effort on the Claude API is high.
One more thing: Fable 5.2 and Mythos 5.2 are the same underlying model. Fable is open to users and has stricter guardrails. Mythos is only available to organizations that pass life-sciences or cybersecurity verification, so it isn’t “a smarter, different model.”
Fable 5.2’s $550 Bill: Check Three Prices Before Running Long Tasks
Felix’s exact words were roughly $550, “heavily cached.” Recalculating with Anthropic’s official list prices (per million tokens: $8 input, $40 output, $0.20 cache read) shows where the money went. What follows is third-party arithmetic, not an invoice he published.
| Scenario | Input side | Output side | Total |
|---|---|---|---|
| Felix’s reported total | ~$442 (backed out) | $108 | ~$550 |
| All input at $8, no caching | $3,560 | $108 | ~$3,668 |
| All input as cache reads | $89 | $108 | ~$197 |
Output is 2.7M tokens × $40 per million = $108, which is what the model actually pays for “writing.” The remaining ~$442 is spread over 445M input tokens, which works out to about $0.99 per million. That’s far below the $8 input price, and it only adds up if the vast majority of input was served as cache reads. $550 lands between $197 and $3,668, and CellCog ran the same official prices and got the same set of numbers.
The takeaway is simple: this bill is expensive because of repeated reads, not because of those two prompts. Fable 5.2’s cache read price is 2.5% of its input price, much lower than the 10% that’s typical for other Claude models. For long tasks, whether you can afford to run them comes down to your cache hit rate.
Before You Run a Multi-Hour Task Yourself, Check These Three Prices
If you plan to run this kind of multi-hour agent task yourself, get the input, output, and cache read prices straight first. On 2026-11-11, claude-fable-5-2 on APIYI (apiyi.com) is $8 input, $40 output, and $0.20 cache read, matching Anthropic’s official list prices.
| Model | Input | Output | Cache read | Available on |
|---|---|---|---|---|
claude-fable-5-2 |
$8 | $40 | $0.20 | Anthropic (official), APIYI (apiyi.com) |
claude-fable-5-1 |
$10 | $50 | $0.25 | Listed in the APIYI docs the same day |
claude-opus-5-5 |
$4 | $20 | $0.20 | Listed in the APIYI docs the same day |
(All prices are per million tokens, as of 2026-11-11.)
A few things to watch for when you integrate:
- base_url:
https://api.apiyi.com/v1, model ID:claude-fable-5-2 - The endpoint uses messages (the docs also list chat). It isn’t in the Codex group, so don’t drop this ID into Codex
claude-fable-5-2-thinkingcosts the same; the official model’s adaptive thinking can’t be turned off anyway, so that suffix isn’t a thinking toggle- You don’t need Fable 5.2 for short tasks. As of the same day,
claude-opus-5-5is $4 / $20 - Models and prices follow the platform’s model list, which you can check at docs.apiyi.com/models
What Fable 5.2 and Saltline Mean for You
For developers already calling the Claude API
- Change how you estimate costs: On long-running tasks, cost is driven mainly by the input side, and output is the smaller piece. If you only look at “the prompt is just two sentences,” you’ll badly underestimate the bill.
- Make caching your first priority: With the same 445 million input tokens, cached and uncached runs can differ in cost by more than 10x. Keeping the prefix stable so the context gets hit again and again saves more money than trimming the prompt.
- Model roles are clearer now: Fable 5.2 suits unattended tasks that run for several hours, while a cheaper model is enough for everyday short calls.
For “browser game demo” posts and how they spread
- 3A is a visual target: The prompt asked for one small-scale level that looks like it could keep up with a 3A game. It didn’t ask for a full commercial game running in the browser.
- Keep the sources straight: The person who reposted the video, the person who built the game, and other demos released the same day are three separate things. Mixing them up makes it easy to draw the wrong conclusion.
- What you can see has limits: Opening the page shows you the code and interfaces of the final version only. It can’t prove that nobody stepped in during those 8 hours, and it can’t prove that every asset was generated pixel by pixel.
Frequently Asked Questions (FAQ)
Q1: What is Saltline, and how does it relate to Fable 5.2?
Saltline is the first-person shooter in the Three Games collection that Felix Rieseberg released. Its subtitle is Waking the Harbormaster. The collection’s footer says all three games were made by Claude Fable 5.2, kept as the first draft, with no human feedback. It’s a demo an employee posted on their own, not a benchmark from the launch post.
Q2: Is TokenGremlin’s 49-second video the same one as Felix’s post?
It’s not the same video file, but the footage shows the same game, Saltline. TokenGremlin said in a reply that it was a different video, and that he didn’t know Felix would post about it when he shared his. His claim in that reply, “8 hours, all generated by Fable 5.2,” matches Felix’s bill, but it’s secondhand, not an experiment log.
Q3: When was Fable 5.2 released, and how does it differ from Mythos 5.2?
Fable 5.2 was released on 2026-11-09, and it shares the same underlying model as Mythos 5.2. Fable is open to users and has stricter guardrails, while Mythos is only available to organizations that have passed domain-specific verification. As of 2026-11-11, Mythos 5.2 doesn’t appear in the APIYI apiyi.com docs or in the pricing endpoint.
Q4: Did nobody really step in during those 8 hours?
All we can see right now is Felix’s own account and the public pages. He says it was built from scratch with no human feedback, while the top of the page says “User-generated content, unverified.” Reading the source only confirms that it’s a self-contained WebGL page. It can’t prove how it was made, and I haven’t seen any independent audit.
Q5: What should I watch for when calling claude-fable-5-2 through the API?
Use the messages endpoint, set base_url to `https://api.apiyi.com/v1`, and enter `claude-fable-5-2` as the model ID. It isn’t in the Codex group, and the `-thinking` suffix costs the same but isn’t a toggle. Before you start a long task, check that day’s pricing in the model list on APIYI apiyi.com, and plan your caching ahead of time.
Q6: Should I use Fable 5.2 for short tasks too?
You don’t need to. Fable 5.2 is positioned for demanding reasoning and agent tasks that run for hours, and short Q&A won’t benefit from its 1M context window. On the same day, `claude-opus-5-5` was priced at $4 / $20 for input and output, which is better value for everyday calls.
Fable 5.2 Key Takeaways
- One web page: Saltline is a self-contained WebGL page of about 3.6MB, not a console blockbuster.
- Scope of one level: The prompt asked for a tiny level, a task of about five minutes. “AAA” was only the visual target.
- Why it looks AAA: Physically based materials, fog, environment reflections, and rain are enough to carry a single level.
- The extra step the model took: Fable 5.2 wrote unattended for hours at a stretch, and its 1M context window held the whole page together.
- Where the bill goes: Input is roughly 165 times output, so most of the money goes to repeated reads.
- Check three prices first: $8 for input, $40 for output, and $0.20 for cache reads. On the day I checked, APIYI (apiyi.com) matched the official prices.
Summary
The Saltline video is worth a closer look on three levels:
- No magic on the browser side: WebGL has been able to render this kind of scene for a long time. The real trick is squeezing all of a level’s data into a single page of about 3.6MB.
- More stamina on the model side: Fable 5.2 can set its own scope, write the page, and pack in the assets. It keeps going for several hours without anyone watching.
- Reads drive the cost: Of the roughly $550 total, about $442 went to repeatedly re-reading content that had already been written. Caching decides whether this bill lands around $197 or $3,668.
If you treat “AAA” as a visual target and “one prompt” as the starting point of a long task, you’ll estimate your own tasks much more accurately.
📚 References
- Anthropic announcement post: Claude Fable and Mythos 5.2
- Link:
anthropic.com/claude-fable-and-mythos-5-2 -
Notes: Official statements on model positioning, pricing, fast mode, and more
-
Fable 5.2 model documentation: context, max output, knowledge cutoff
- Link:
platform.claude.com/docs/en/models/fable-5-2/overview -
Notes: Model ID and spec parameters
-
Felix Rieseberg’s billing post: prompt, timing, and token counts
- Link:
x.com/felixrieseberg/status/2119925633564463609 -
Notes: Original source for the ~$550 cost, ~2.7M output tokens, and ~445M input tokens
-
Saltline public page: the level you can open directly in a browser
- Link:
claude.ai/artifact/BGY1SztrAYcJQHSsnHHGmp -
Notes: The top of the page states the content is user-generated and unverified
-
CellCog coverage: a recalculation of the same bill, plus a quote of the second half of the prompt
- Link:
cellcog.ai/blog/fable-5-2-one-shot-game-cost -
Notes: Third-party arithmetic that matches the recalculation in this article
-
APIYI model list: current models and pricing
- Link:
docs.apiyi.com/models - Notes: Models and pricing are subject to the platform’s model list
Author: APIYI Technical Team
Get in touch: Reach out to us on the APIYI homepage at apiyi.com. For more resources, visit the documentation center at docs.apiyi.com.
