550 USD, 8 hours: How exactly does AI independently create a 3D game?

550 USD, 8 hours: How exactly does AI independently create a 3D game?

Summary: A developer’s self-reported Saltline experiment shows how long-horizon code generation can deliver a playable prototype. Understanding the estimated API cost means looking at both caching and output billing.

On November 9, 2026, Anthropic engineer Felix Rieseberg published an experiment. He gave Claude Fable 5.2 a single prompt, offered no human feedback afterward, and ended up with a 3D first-person shooter called Saltline that runs directly in a browser. By his own account, the generation took about 8 hours, consumed roughly 445 million input tokens and about 2.7 million output tokens, and came to an estimated $550 at API pricing.

Two things stand out about this experiment. First, the model folded work that normally belongs to several different roles — scene construction, game logic, models and textures, shaders, sound effects, and player interaction — into a single long-horizon code generation task, with every visual element existing as code and functions. Second, if all 445 million input tokens were billed at the standard input rate, the cost would exceed $3,500, yet the developer’s reported estimate is only about $550 — the difference comes mainly from caching. The economics of complex AI development tasks depend on how much context gets reused; conclusions drawn from input and output unit prices alone will be badly distorted.

Below, I’ll first cover the public data and experimental conditions behind Saltline, then break down exactly which parts of game development the AI handled, then work through where the $550 figure comes from using Fable 5.2’s official pricing — and where the reproducibility stops. After that I’ll lay out a cost framework that separates model invocation, development execution, and production runtime, and finally discuss the distance between a playable prototype and a commercial game when it comes to this kind of solo AI development.

ai-built-3d-game-saltline-550-dollars-8-hours-en-image-0

To Know: Understanding the Terminology of the AI 3D Game Experiment

Term Explanation
Token The unit of measurement for model input and output. API billing is based on the number of tokens.
API The interface applications use to call model services; developers use it to connect the model to their own programs.
Prompt Caching Saves the processed results of recurring context so later requests can reuse them directly, cutting cost and latency.
Cache Write The first time reusable context is stored in the cache; the unit price is usually higher than regular input.
Cache Read When later requests hit existing cache, they’re billed at a price far below regular input.
TTL How long the cache stays valid. Once it expires, the context has to be written again. Fable 5.2 offers two tiers: 5 minutes and 1 hour.
Batch API A way to invoke models for asynchronous batch jobs. It suits scenarios that don’t need an immediate response, and comes with a discount.
Agent A model application that can call tools, read and write files, and carry out multi-step tasks.
Playable prototype An early game build used to validate gameplay and technical feasibility, with limited content and polish.
Shader A small program that runs on the GPU, using mathematical functions to determine color, lighting, and material appearance.
Procedural generation Using rules and algorithms to construct models, textures, sound, and other content at runtime, replacing pre-made asset files.
WebGL / Three.js WebGL is the 3D rendering interface browsers use to call the GPU; Three.js is a JavaScript 3D graphics library built on top of it.

1 Eight Hours, $550: How an AI 3D Game Was Born

1.1 Experimental Conditions: One Prompt, No Human Feedback

Felix Rieseberg’s task for the model was clear: build a small-scale first-person shooter that looked as close to a AAA game as possible, with no follow-up human feedback at any point. In his announcement, he stressed that what he wanted to test was exactly how far the model could get with no intervention.

Here, “AAA” is both the experimental target and a visual analogy. AAA normally refers to high-spec commercial games built with massive budgets and large teams; Saltline is positioned as a small-scale, playable prototype with a single mission level and a primarily single-player experience.

1.2 What’s in Saltline

Saltline is set in a container port on a rainy night, with warehouses, a dock, and stacked shipping containers. The player has to shut down three signal relay stations and extract, running into airborne patrol drones and ground-based mechanical hounds along the way.

The game supports first-person movement, camera control, shooting, interaction, and mission objectives, along with rain, lighting, ambient audio, and weapon effects. It’s also lightweight to try: just open it in a browser, with keyboard/mouse and touch support, graphics quality settings on the page, and a low-quality mode you can switch to if it stutters.

1.3 The Numbers the Developer Shared

All of the figures below come from Felix Rieseberg’s own public posts on X, and the GitHub mirror notes that these numbers haven’t been independently audited by a third party.

Item Value as stated by the developer
Model Claude Fable 5.2
Development time About 8 hours
Input tokens About 445 million (heavy use of caching)
Output tokens About 2.7 million
Estimated cost About $550 (estimated at API pricing)
Development method Single prompt, no human-feedback iteration
Artifact size Standalone HTML version, about 1.43MB (1,425,707 bytes)

The $550 is the estimated expense of a single model-generation experiment. Once the game file is generated, players run it locally in their browser and no further Claude API calls are triggered, so that money has nothing to do with how many people play it.

2 What AI Actually Did in This 3D Game’s Development

2.1 All Models and Textures Are Code

On November 10, the developer clarified further: everything in the game—models, textures, and the rest—is built from code and shaders generated by Claude. There are no standalone image or 3D model assets in the project. In his words, “everything is code—textures and models are functions.”

That explains why Saltline weighs only about 1.43MB. Traditional games ship a large amount of pre-made models, textures, and sound files; Saltline ships the mathematical rules that generate that content. The browser reads the code and builds the scene in real time at runtime.

2.2 Six Stages Folded Into a Single Generation Task

Traditional 3D game development usually splits work across different roles—design, modeling, materials, programming, audio, and so on. In Saltline, the model handled the following work in sequence within a single project:

  • Scene construction: Procedurally building the port, warehouses, shipping containers, and other structures from vertices and geometry parameters.
  • Game logic: Mission objectives, enemy behavior, hit detection, and the extraction flow.
  • Models and textures: Generating metal surfaces, stains, and color variation with noise and mathematical functions.
  • Shaders: Computing lighting, materials, rainy-night reflections, and other visual effects on the GPU.
  • Sound effects: Ambient and weapon sounds are generated procedurally as well.
  • Player interaction: Keyboard/mouse and touch input, camera control, and graphics quality settings.

In a traditional workflow, these stages require handoffs across tools and people. In Saltline, they became different modules in the same codebase. The model’s long context window let it keep reading the existing code and technical decisions, ensuring the modules stayed consistent with one another.

2.3 How the Browser Runs This Game

Saltline takes the local browser rendering route, with the visuals generated on the player’s own device. The runtime flow goes roughly like this:

  1. The browser reads the HTML file and starts executing JavaScript.
  2. It initializes the Three.js and WebGL rendering environment.
  3. The program generates scene geometry, materials, textures, and sound from code.
  4. The GPU handles graphics rendering, and the player controls the character via keyboard/mouse or touch input.
  5. Game logic keeps updating and the browser refreshes the frame.

ai-built-3d-game-saltline-550-dollars-8-hours-en-image-1

A small file and lightweight running are two different things. 1.43MB of code can create a large number of geometries and materials at runtime; memory and GPU load depend on scene complexity. The standalone demo page also warns: initialization may be slow—if it hangs on the waiting screen, check WebGL 2 and browser hardware acceleration—and if it stutters, switch to lower graphics quality.

3 Why an AI 3D Game with 445 Million Tokens Cost Only $550

3.1 Official Pricing for Claude Fable 5.2

Fable 5.2 launched on November 9, 2026, with a 1M-token context window and a maximum output of 128K tokens. Here’s the official standard pricing:

Billing Item Price per Million Tokens Relative to Regular Input
Regular input $8 100%
Output $40 500%
5-minute cache write $10 125%
1-hour cache write $16 200%
Cache read $0.20 2.5%

On top of that, Fast Mode runs $16 for input and $80 for output (per million tokens), and the company says output speed can go up to 2.5x faster. Cache reads cost just 2.5% of regular input — and that’s the key to understanding the $550.

3.2 Theoretical cost when billed as regular input

If we ignore caching entirely and just multiply the developer-published token counts by the standard unit prices, the result is wildly different from $550:

Billing basis Input cost Output cost Total
Everything billed as regular input 445 × $8 = $3,560 2.7 × $40 = $108 $3,668
Everything billed as cache reads (theoretical lower bound, cache writes excluded) 445 × $0.20 = $89 2.7 × $40 = $108 $197
Developer’s own estimate — — about $550

The two extreme bases give us a range: an upper bound of roughly $3,668 and a lower bound of roughly $197. The developer-reported figure of about $550 falls inside that range and clearly leans toward the lower bound, which tells us that a substantial chunk of the input was billed at the cache-read price.

There’s one more detail worth noting: at standard prices, 2.7 million output tokens come to about $108, roughly one-fifth of the $550 estimate. Input volume is over a hundred times the output volume, yet under caching the output cost still takes a sizeable share.

ai-built-3d-game-saltline-550-dollars-8-hours-en-image-2

The unit-price comparison in the chart above can be applied directly to your own Agent tasks to make estimates. If you’d rather validate the impact of cache hits on your bill with a small-scale task first, you can use the same API key on APIYI (apiyi.com) to invoke Claude and several other models, then check the usage details to see how costs shift under different context strategies.

3.3 Why caching can dramatically cut the cost of long-horizon coding

In long-running, multi-turn AI coding sessions, the model re-reads a large amount of identical content every single turn: project background, file structure, existing code, development conventions, and the technical decisions made earlier. An 8-hour generation process means this context gets submitted over and over — and that’s exactly how the 445 million input tokens pile up.

Prompt caching saves these repeated prefixes and bills cache hits at the cache-read rate. The full caching bill comes down to three parts:

  • Cache write: the first write costs more than regular input — 1.25× for the 5-minute tier, 2× for the 1-hour tier.
  • Cache read: later hits cost just 2.5% of the normal price.
  • Cache expiration (TTL): once the validity period passes, you have to write again and pay the write fee a second time.

So the TTL tier you choose, whether your context structure stays stable, and how long the gap is between two requests all affect the final cost. Constantly changing content near the front of the context invalidates the cache and actually drives write overhead up.

3.4 How far can the public data be recomputed?

The publicly available material gives total input, total output, and an estimated total price — but no complete billing breakdown. None of the following key numbers are disclosed:

  • The token counts for regular input, cache writes, and cache reads, respectively;
  • The usage for the 5-minute cache and the 1-hour cache, respectively;
  • Whether any other API call fees apply.

Since cache writes come in two price tiers, there are more unknowns than knowns, and those three numbers alone aren’t enough to derive a unique cache hit rate. What can be stated with confidence is this: the $550 figure falls inside the theoretical range above, and caching did the heavy lifting on cost reduction in this experiment.

4 How to Actually Calculate the Real Cost of AI Programming Tasks

4.1 A Three-Layer Cost Framework

When discussing “how much it costs to build a game with AI,” you first need to be clear about which layer of cost you’re actually measuring. Saltline’s $550 only covers the first layer.

Cost Layer What It Covers Included in Saltline’s Figure?
Model invocation cost Input, output, cache writes and reads, batch discounts, tool calls Yes (about $550, developer estimate)
Development execution cost Task design, debugging and testing, runtime environment, code repository, external resources, personnel time Not disclosed
Product operation cost Hosting, CDN traffic, database, online services, ongoing maintenance Not included

The structure of a local web game means its AI cost is concentrated in the development phase, with rendering handled by players’ own devices. By contrast, cloud gaming and real-time AI world models incur ongoing server compute costs every time a player plays — the cost curves for these two types of products are completely different.

4.2 Which parts suit the Batch API

Claude’s official API offers a Batch API, and eligible batch inputs and outputs get a 50% discount. It’s a good fit for non-realtime code generation, bulk content processing, and offline evaluation — for example, generating configs for a bunch of levels in one go, or running code reviews in bulk.

Agent-style development like Saltline needs to decide its next action based on the previous step’s result. That’s a strongly interactive serial flow, so it’s hard to apply batch discounts directly. In real projects, the more practical approach is to split things up: the main development loop relies on caching to cut costs, while offline subtasks that can run in parallel get handed to the Batch API.

4.3 Estimate your AI coding bill with code

This minimal example shows how to make a single call through an OpenAI-compatible interface and read the usage fields from the response — a starting point for cost tracking:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # APIYI unified interface
)

resp = client.chat.completions.create(
    model="YOUR_MODEL_NAME",  # Replace with a model name from the platform's list, e.g. Claude
    messages=[{"role": "user", "content": "Write a rotating cube with Three.js"}]
)
print(resp.choices[0].message.content)
print(resp.usage)  # Record prompt_tokens / completion_tokens for cost accounting
View the full implementation: a cost estimator with cache accounting
import openai
from dataclasses import dataclass

# Claude Fable 5.2 official standard pricing (USD / million tokens)
PRICE = {
    "input": 8.0,
    "output": 40.0,
    "cache_write_5m": 10.0,
    "cache_write_1h": 16.0,
    "cache_read": 0.20,
}

@dataclass
class Usage:
    input_tokens: float = 0        # Regular input
    cache_write_5m: float = 0      # 5-minute cache write
    cache_write_1h: float = 0      # 1-hour cache write
    cache_read: float = 0          # Cache read
    output_tokens: float = 0       # Output

def estimate_cost(u: Usage) -> float:
    """Accumulate each billing item separately; unit: USD"""
    m = 1_000_000
    return (
        u.input_tokens / m * PRICE["input"]
        + u.cache_write_5m / m * PRICE["cache_write_5m"]
        + u.cache_write_1h / m * PRICE["cache_write_1h"]
        + u.cache_read / m * PRICE["cache_read"]
        + u.output_tokens / m * PRICE["output"]
    )

# Reproduce the two theoretical bounds from the article (developer-reported total tokens)
upper = estimate_cost(Usage(input_tokens=445e6, output_tokens=2.7e6))
lower = estimate_cost(Usage(cache_read=445e6, output_tokens=2.7e6))
print(f"All regular input: ${upper:,.0f}")   # About $3,668
print(f"All cache reads: ${lower:,.0f}")   # About $197

# Accumulate real usage in your own project
client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

def run_step(messages, model="YOUR_MODEL_NAME"):
    resp = client.chat.completions.create(model=model, messages=messages)
    usage = resp.usage
    print("prompt:", usage.prompt_tokens, "completion:", usage.completion_tokens)
    return resp.choices[0].message.content

The estimator adds up the five billing items separately, so you can plug in your own project’s usage breakdown directly. Platforms may return cache fields differently, so when integrating, go by the actual usage structure in the response.

🚀 Quick start tip: Before putting long-running Agent tasks into production development, it’s worth claiming the free trial credits for new users at APIYI apiyi.com, running a small Three.js scene through the full “generate—run—fix” loop, and recording token usage each round. Then use the estimator above to work out the budget for the full project.

5 Where Are the Limits of AI Solo Development for 3D Games?

5.1 Playable Prototypes vs Mature Commercial Games

Saltline proves that the model can deliver a complete, playable small-scale game without human intervention: it has a scene, enemies, quests, and audiovisual presentation. A mature commercial game also needs a large amount of level content, long-term balance tuning, multi-platform adaptation, localization, anti-cheat, and large-scale user testing—none of which were covered in this single experiment.

The “JiMao · Domestic AAA Blockbuster” that circulated on Chinese social platforms is actually the Chinese version or a repackaged version of Saltline. “Domestic AAA blockbuster” was the label used when it circulated; its development origin is still this Fable 5.2 experiment.

5.2 One-Shot Generation vs Ongoing Maintenance

One-shot generation solves “from zero to one.” After a game launches, version iteration, bug fixes, and content additions require the model or developer to repeatedly modify the existing code. The context size required for long-term maintenance will keep growing, and caching strategy and code organization will have an increasingly obvious impact on subsequent costs.

5.3 Feature Completion vs Performance Optimization

Features being usable and running smoothly are two separate engineering goals. Saltline’s demo page offers a low-quality option and prompts users to check WebGL 2 and hardware acceleration—precisely because performance is still constrained by players’ devices and browser capabilities. Unity’s official documentation also notes that the Web platform has limitations in file systems, threading, memory, and mobile device support, and browser performance optimization for complex games remains difficult.

5.4 Looking at Saltline as a Representative Experiment

Saltline’s value is that it provides a clear reference point: with a relatively capable long-context model, reasonable cache usage, and a clear single objective, the model invocation cost of one-shot generating a browser 3D prototype is on the order of hundreds of dollars. Its 8 hours and $550 come from the developer’s self-reported single experiment; other developers’ results will vary with prompt design, task complexity, caching strategy, and model version.

The third-party platform AI8Games has cataloged a set of browser games generated with the participation of models such as Claude Fable 5.2. At the time of retrieval, it showed 62 playable games and 27 video showcase works. This is third-party curated data; it reflects that such experiments are becoming more common, but it does not represent official statistics.

💡 Recommendation: Different models differ noticeably in long-horizon code generation, cache pricing, and output token pricing. For the same game prototype task, the total bill on different models can differ by several times. We suggest comparing the output quality and token consumption of several mainstream models on APIYI apiyi.com using the same prompt, and then deciding which one to use for formal development.

6. Common Questions About the AI 3D Game Experiment

Q1: Is Saltline’s $550 an actual bill that was paid?

It’s an estimate Felix Rieseberg made based on API pricing, and it hasn’t been audited by a third party. Public information also doesn’t include the separate usage for regular input, cache writes, and cache reads, so the billing breakdown can’t be reconstructed exactly.

Q2: Why did 445 million input tokens cost so little?

Long-horizon coding repeatedly submits the same project context. Once that content hits the cache, it’s billed at $0.20 per million tokens, just 2.5% of the $8 regular-input rate. If everything were billed as regular input, the cost would be about $3,668. The developer’s estimate is about $550, with the difference mainly coming from caching.

Q3: Does each playthrough incur AI invocation costs?

No. Once generated, Saltline is an HTML file of about 1.43 MB. The game runs locally in the player’s browser and is rendered by the player’s GPU; it doesn’t call the model API while running. The $550 was a one-time development-stage cost.

Q4: How can I reuse this kind of long-horizon code generation in my own project?

The key is to keep the model working on a stable context structure. Put the spec, technical plan, and file structure in a fixed section at the front of the prompt so they’re more likely to hit the cache. Log the usage after each turn so you can estimate the budget. You can first run a small scenario on APIYI apiyi.com with free credits, confirm that caching and usage accounting match expectations, and then scale up the task.

Q5: Can a developer reproduce a similar game on the same budget?

Results will vary depending on the prompt, target complexity, caching strategy, and model choice. Saltline was a successful one-off experiment and is best used as an order-of-magnitude reference. For an actual budget, it’s better to extrapolate from real usage in a small trial run. With the unified interface at APIYI apiyi.com, you can switch between different models in the same codebase, making it easier to compare costs side by side.

Q6: What’s the difference between Saltline and AI-generated games like Genie 3?

In Saltline, AI writes code and the browser runs that code. The game rules are written in advance, and the graphics are rendered by the local GPU. World models such as Genie 3, Muse, and Oasis instead predict the next frame in real time based on the current state and player input. They require continuous inference, so every playthrough incurs compute costs. The two approaches have completely different cost structures and technical constraints.

7 Summary: How to Read the Numbers $550 and 8 Hours

Saltline’s experiment demonstrates three things:

  1. AI can integrate multiple game development stages into a single code generation pass: scenes, logic, models, textures, shaders, sound effects, and interactions are all delivered as code, producing a roughly 1.43MB single-file browser game.
  2. Caching determines the economics of long-horizon AI coding: 445 million input tokens at normal pricing would cost about $3,668, while the developer’s self-reported estimate is about $550 — the 2.5% cache-read unit price is the key variable.
  3. $550 is just the model invocation cost: development execution, product runtime, and subsequent maintenance all fall outside this number. Saltline is a representative playable-prototype experiment.

If you’re planning to have an Agent take on a similar long-horizon development task, the most effective preparation is to build cost-accounting habits first: record input, cache, and output usage separately, then estimate your budget based on real data. We recommend using APIYI apiyi.com for quick validation — the platform offers OpenAI-compatible interfaces, unified multi-model invocation, and free trial credits for new users.

References

  1. Saltline standalone experience page: game demo and FAQ
  2. Link: saltline.games
  3. Description: includes onboarding, graphics settings, controls, and other experience details; the Chinese version is at saltline.games/zh

  4. Felix Rieseberg’s original launch post: source for development time, tokens, and cost data

  5. Link: x.com/felixrieseberg/status/2119925633564463609
  6. Description: first-hand data self-reported by the developer

  7. Saltline code mirror and README: file data and data attribution notes

  8. Link: github.com/realcodebear/saltline-fable-5.2
  9. Description: notes that the relevant figures have not been independently audited by a third party

  10. Jimao Chinese version GitHub repository: archive of the domestic circulation version

  11. Link: github.com/Megasu/jimao-3a-game
  12. Description: provides the index.html file size and offline run instructions

  13. Claude Fable 5.2 model specs and pricing: Anthropic official documentation

  14. Link: platform.claude.com/docs/en/models/fable-5-2/overview
  15. Description: official unit prices for input, output, cache writes, and cache reads

  16. Three.js official documentation: browser 3D graphics library

  17. Link: threejs.org/docs
  18. Description: foundational material for understanding how Saltline builds its scenes

  19. Unity WebGL technical overview: Web platform limitations

  20. Link: docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html
  21. Description: browser game limitations around threads, memory, and mobile

Author: APIYI Technical Team
Technical inquiries: Feel free to contact us via the APIYI apiyi.com homepage; more integration resources are available at the docs.apiyi.com documentation center

Related Articles

Similar Posts