No. 31 Friday 13 November Game dev, software and AI

The cheap model does the typing

Google's new coding setup plans with a strong model and hands the edits to a cheaper one, inside a single task. Plus Rust 1.100, lockfiles for GitHub Actions, a C++ standard that failed its vote, and a studio that left Fortnite for its own engine.

The short version

  • Software and AI Google's Antigravity now lets one task switch models: Gemini 4 Carbon plans, the new Hydrogen edits and tests, and Carbon takes over when Hydrogen gets stuck. Google reports near-Carbon success for 24% less quota.
  • Software and AI Hydrogen costs $1.50 in and $7.50 out per million tokens. In Simon Willison's drawing test it used a fifth of Carbon's cost per image.
  • Software and AI Rust 1.100 lets Cargo skip crate versions younger than a set age, and GitHub Actions now has a lockfile, so workflows can name readable tags while a file pins the exact commits.
  • Games and software C++26 became the first C++ draft to fail its ISO ballot, over Contracts; the committee meets again from November 16.
  • Game dev A studio behind 14 Fortnite islands moved its card game to Defold after a payout change cut one game's income by about 40%: 4-second boot, 6,500 tests, an MCP server for agents.
Software and AI Release

Plan with the big model, edit with the small one

Google's coding tool can now switch models in the middle of a task: an expensive model works out the plan, a cheaper one does the edits and runs the tests, and the expensive one steps back in only when the cheap one gets stuck.

ContextAntigravity is Google's agent-first coding environment; Gemini 4 Carbon and Argon are its top models, released earlier this week.

How Orchestrator splits one task, as Google's Antigravity post describes it. After a hand back, Hydrogen resumes on the repaired plan.

On November 12 Google released Gemini 4 Hydrogen, the cheapest model in the Gemini 4 family, and a new Orchestrator option in Antigravity's model menu. Orchestrator pairs Hydrogen with a stronger model in one task. Carbon starts read-only, explores the code and its dependencies, and writes a plan that includes when to re-plan. Hydrogen then makes the edits, updates packages and runs the tests.

If Hydrogen hits trouble, the task goes back to Carbon, which inspects the state, repairs the plan and lets Hydrogen resume. For parallel work, Carbon coordinates while Hydrogen runs worker and checker agents in separate workspaces.

Google reports that Orchestrator reached near-Carbon task success on Terminal-Bench while using about 24% less quota and finishing about 19% faster on average. These are the vendor's own numbers; no independent test of Orchestrator has been published yet.

Technical details

Hydrogen offers four thinking levels: low, medium, high (the default) and a new xhigh. Google cites 51 on the Artificial Analysis Intelligence Index at high (Argon scores 50) and 54 at xhigh, and 57% on Terminal-Bench 4.1 against 18.2% for Gemini 3.8 Flash. Google's two posts name different Terminal-Bench versions for the Orchestrator result (4.0 on blog.google, 4.1 on the Antigravity blog).

Availability: Hydrogen is in the Gemini API, AI Studio and Android Studio, and in Antigravity for paid AI Pro and Ultra plans. Orchestrator (Carbon) is for Ultra; Orchestrator (Argon) is for Pro and Ultra. The context window is 1 million tokens in and up to 1 million out, priced flat across it.

Antigravity's SDK lets you build the same split yourself, assigning models to roles. Google's example is an issue triage system where Hydrogen agents triage, code and ask clarifying questions, and a Carbon agent takes large refactors and security checks; no code for it is published yet.

Why it mattersPicking one model per session wastes money on easy steps or quality on hard ones. A planner and worker split is a pattern you can copy in any agent setup, and now there is a vendor measurement of what it saves.

For youThis is the same shape as a Claude Code main session delegating to cheaper subagents. Try a Fable planner with Haiku 5.5 subagents doing the edits and test runs on one plugin task, and compare cost and outcome against an all-Fable run.

quota
The amount of model usage a subscription allows in a period; cheaper models use less of it per task.
Terminal-Bench
A public benchmark that gives an agent real tasks to complete in a command-line environment and checks whether they work.
read-only
Allowed to look at files and run inspections, but not to change anything.

Sources Google Antigravity: Hydrogen and OrchestratorGoogle: Introducing Gemini 4 Hydrogen

More like this Less like this

One task, two models

What the planner and worker split costs and saves.

Software and AI News

Same drawing, a fifth of the cost

Simon Willison asked each new Gemini model to draw the same picture in code. Hydrogen did it for 2 to 4 cents; the bigger models spent 17 to 20 cents, mostly on long thinking.

Cost of one run of the same prompt, by model and thinking level:

One prompt per model, 40 input tokens each. Hydrogen wrote 3,000 to 5,300 output tokens; Carbon wrote 20,305 and took over four minutes. Willison found Hydrogen's drawing plainer.

Why it mattersOutput tokens drive the bill, and bigger models think longer. For routine steps, the cheaper model's speed and price add up fast.

Sources Simon Willison: llm-gemini 0.37

More like this Less like this

Software and AI Release

What the split saves, and what Hydrogen costs

Google's own numbers for Orchestrator, and Hydrogen's price per million output tokens. Carbon and Argon cost $10 per million output tokens until November 30, then $20.

24%less quota than Carbon alone, per Google

19%faster on average, per Google

$7.50per million output tokens for Hydrogen

Input costs $1.50 per million tokens and cached input $0.075. Willison notes that Claude Haiku 5.5 and GPT-6 Luna cost $0.10 in and $0.50 out, so Hydrogen is 15 times their price: cheap next to Carbon, not cheap overall.

Why it mattersThe saving from a split depends on the gap between the two prices. That gap doubles on December 1, when Carbon and Argon double in price.

For youBefore December 1, note which agent runs lean on Carbon or Argon through Copilot or the AI Gateway; their cost doubles that day.

cached input
Input the provider has already processed in an earlier request and can reuse, billed at a small fraction of the normal price.

Sources Simon Willison: llm-gemini 0.37Google Antigravity blog

More like this Less like this

Faster builds, pinned dependencies

Rust tooling, supply chain settings and this week's Claude Code.

Games and software Release

Relax runs Rust straight from source, and patches edits live

An experimental tool from the Makepad team skips Rust's slow compile step during development: it compiles each function the first time it runs, so a large 3D game reached its first frame in 11 seconds instead of about three minutes.

Seconds until the program is running, measured by the Makepad team on November 12 (M4 laptop):

The cargo figure is the page's own estimate of about three minutes. Tests: 92 re-run after saving a file. Author-reported numbers.

Technical details

Each function is compiled at its first call (interpreted or at a low optimisation level) and hot functions are recompiled at a higher level in the background. Edits are patched into the running process, but changes to struct layout, imports, trait or impl headers and macros need a restart.

Optimised code is still slower than a release build: 1.12 times rustc's time on x64 and 1.24 times on arm64 (geometric mean of 21 workloads). Windows is untested, some crates do not run yet, and relax check is not faster than cargo check on large packages.

Why it mattersCompile time is the slowest part of an edit-run loop, for people and for coding agents that rebuild after every change. Relax is a JIT for development only; release builds still use cargo.

JIT
Just-in-time compilation: turning code into machine instructions while the program runs, function by function, instead of all at once beforehand.

Sources Makepad: Relax

More like this Less like this

Software and AI Release

Rust 1.100

Released November 12, with a dependency cooldown, the never type and custom allocators.

The new Rust release can refuse dependency versions published only hours ago, which gives the community time to spot a poisoned package before it reaches your build.

Set a minimum publish age and Cargo picks only crate versions older than it. The release notes say cooldowns reduce the risk from some supply chain attacks but are not a complete defense, and cargo install ignores the setting.

Cooldown
global-min-publish-age in .cargo/config.toml
Never type
! is stable after 10 years
Allocators
The Allocator trait is stable
New lint
Cargo warns about unused dependencies

Try itglobal-min-publish-age = "3 days" under [registry] in .cargo/config.toml

Technical details

Stabilising ! required a small breaking change so that Infallible can become an alias of it; the notes say this should be rare but may make the compiler find more unreachable code. Also new: DropGuard, which runs a closure when dropped and can be dismissed. A consistent build directory layout may break scripts that worked around the old one. The unused dependency warning appears only when every build target is built, and not for dev-dependencies.

Why it mattersMost poisoned packages are caught within days. A cooldown is a one-line setting that keeps your builds behind that window.

For youSet the cooldown in any Rust tooling repos, and look for the npm equivalent for the Node and Supabase projects.

supply chain attack
Slipping malicious code into a package that many projects install, so it spreads through their builds.
never type
A Rust type for values that can never exist, used for functions that never return or results that cannot fail.

Sources Rust blog: Announcing Rust 1.100.0

More like this Less like this

Software and AI Do this

Pin your GitHub Actions in a lockfile, not in hashes

ContextA GitHub Action is a reusable step that a workflow downloads and runs; if its tag is moved to malicious code, every workflow using that tag runs it.

Workflows usually pin third-party actions to long commit hashes for safety, which nobody can read. A new GitHub tool keeps readable version tags in the workflow and records the exact commits in a lockfile that CI checks.

Hugo van Kemenade's setup, posted on November 11 and already used in Pillow and CPython:

  1. Install

    Add the extension with gh extension install github/gh-actions-lock.

  2. Lock

    Run gh actions-lock in the repo. It writes .github/workflows/actions.lock with each tag's commit and repository IDs.

  3. Use tags

    Replace hash pins with tags such as actions/checkout@v7.0.1, and commit the workflows with the lockfile.

  4. Verify in CI

    Add a job that installs the extension pinned to v0.4.1 and runs gh actions-lock --verify, so a stale or tampered lock fails the build.

  5. Keep it fresh

    Renovate and Dependabot both update the lockfile; give them a cooldown. zizmor 1.32.0 understands lockfiles as a pre-commit check.

Technical details

The lockfile is machine-generated and starts with a version field, a list of workflows and the actions each uses, then a dependencies map with each tag's ref, commit (as sha1-...), owner_id and repo_id. Adding a new workflow file means running gh actions-lock again, or the verify job fails. The author runs the verify job on ubuntu-slim with persist-credentials: false on checkout.

Why it mattersHash pins protect you but hide what version you run, so they rot. A lockfile keeps the protection and makes reviews and updates readable.

For youDo this first on the radar repo and the game web builds, where workflows already pull third-party actions.

lockfile
A generated file that records the exact version of every dependency, so each build uses the same code.
commit hash
The unique ID of one exact snapshot of a repository; unlike a tag, it cannot be moved.

Sources Hugo van Kemenade: Lock your GitHub Actions

More like this Less like this

Software and AI Release For practitioners

Claude Code 2.1.323: Code Mode, plugin version ranges, a bigger default window

This week's Claude Code update adds an experimental mode where Claude writes small programs to call its tools, lets plugins say which versions they support, and changes two defaults worth checking.

Show the details

From the changelog for 2.1.323, November 13:

  • Code Mode

    An experimental opt-in in which Claude writes JavaScript to call its tools instead of calling them one at a time. Organisations can turn it off.

  • Plugin version ranges

    Plugins can declare engines["claude-code"] in plugin.json; outside that range they are not installed, updated or loaded. claude plugin validate now type-checks TypeScript hook modules.

  • 1M window for unknown models

    A model ID Claude Code does not recognise is now assumed to have a 1M-token window, not 200K. Set CLAUDE_CODE_DISABLE_1M_CONTEXT=1 for smaller models behind a gateway, or sessions can fail once full.

  • Safer starts

    Auto mode falls back to Manual when unavailable, and a startup warning flags Bash allow rules with * in a variable's value, such as Bash(PORT=* npm run dev). The subagentStatusLine setting is removed.

Why it mattersThe context default matters most: anyone pointing Claude Code at a non-Anthropic model with a smaller window should set the variable now.

For youCheck settings for subagentStatusLine and for * inside variable values in allow rules, and add an engines range to any plugin you publish.

allow rule
A Claude Code permission setting that lets a matching command run without asking first.

Sources Claude Code changelogClaude Code releases

More like this Less like this

Engines, tools and a stalled standard

A studio's move off a platform, a Godot add-on, and C++26.

Game dev Lesson

Portentum

A cards-and-dice auto-battler by Snowfall Games, in Steam Early Access since October 28.

ContextDefold is a free, lightweight engine from the Defold Foundation, scripted in Lua and strong on small, fast-loading builds.

A five-person team that made 14 Fortnite games left the platform after a payout change cut one game's income by about 40%, and built its card game in the free Defold engine instead, chasing fast loading and fast iteration.

The Defold editor with Portentum's main menu GUI open: a menu of collection, card packs, quests and shop beside a Play button, with the project's folders listed on the left, including a .claude folder.
Image: Snowfall Games via Defold

Snowfall's Fortnite games have been played more than 9 million times. When Epic changed its payout formula in November 2025, one game earned about 40% less with the same players. The studio's conclusion: it did not control its own growth there.

It chose Defold for speed of iteration (it found Unreal Editor for Fortnite slow to iterate), easy UI work and no royalties. The team also built defold-mcp, an MCP server that lets coding agents build the game and drive a running copy to check their changes.

Team
Five people, two full-time
Fortnite
About 14 games, peak 36,471 players on one
Engine
Defold, Lua, custom GUI pipeline

Why it mattersPlatform payouts can change overnight. A studio that owns its game and its toolchain keeps its income and its pace in its own hands.

For youdefold-mcp is the same idea as Unreal MCP for a smaller engine; worth reading for how an agent drives a running build to check gameplay changes in the browser games.

auto-battler
A game where you build a team or deck between rounds, and the fights then play out on their own.
MCP server
A program that offers tools to AI agents through the Model Context Protocol, a standard way for an agent to call tools in another program.

Sources Defold: Creator spotlight, Snowfall Games

More like this Less like this

Game dev Release

Xogot Modeler

A 3D modeling and level tool for Godot on Windows and Linux, ported from Xogot for Mac.

A free beta add-on lets Godot users rough out levels and props with curved paths and polygon editing right inside the engine, then save them as ordinary Godot meshes.

Godot's 3D editor showing a winding hedge-lined path built from a Bezier plane with collision, next to the Xogot Modeler name and axolotl icon.
Image: Xogot, via the Godot Asset Store

You draw curved geometry along Bezier paths or start from shapes, then edit vertices, edges and faces, extrude and bevel, paint materials and vertex colours, unwrap UVs and add collision. Output is standard Godot meshes, so nothing extra ships with the game.

Price
Free in beta; later versions may be paid
Catch
Each build expires 30 days after it was built
Rights
Sell what you make, no royalties or credit

Why it mattersBlocking out inside the engine means you can walk a level the minute you shape it, without a round trip through Blender.

blockout
A rough version of a level made from simple shapes, used to test layout and movement before any final art.
Bezier paths
Smooth curves controlled by a few draggable points, common in drawing tools.

Sources GameFromScratch: Xogot ModelerGodot Asset Store: Xogot Modeler

More like this Less like this

Games and software News

C++26 failed its ISO ballot, a first for C++

The national standards bodies voted down the draft of the next C++ standard, mainly over a new feature for built-in checks called Contracts. Everything else in C++26 now waits for the committee to decide what to do.

60%of voting members approved, as reported

66.7%needed to pass

The figures come from a LinkedIn post by committee member Robert Seacord, reproduced on herecomesthemoon.net. The committee meets in Brazil from November 16 to 21; the post's author expects a fix could take about a year, since each ballot runs for weeks.

Why it mattersCompilers ship C++26 features piecemeal anyway, but library hardening is tied to Contracts and its timing is now unclear.

For youNo change for Unreal plugin code, which targets C++20; skip planning around Contracts or hardened standard library modes for now.

Contracts
A proposed C++ feature for writing checks on a function's inputs and outputs (pre, post, contract_assert) that the compiler can enforce.
ISO ballot
The formal vote in which national standards bodies approve or reject a draft international standard.

Sources herecomesthemoon: C++26 failed the national bodies

More like this Less like this

Game dev Lesson

How a five-person team keeps a game fast and tested

Snowfall ships only the essentials on first launch and streams the rest, and every pull request runs thousands of tests with no window open.

4 sto boot

68 MBfirst download, about 6 s

6,500tests on every pull request

Card art, cosmetics, music, effect videos and every language except English stream in later. Each pull request also runs a Lua linter and about 30 guard scripts, with the full suite headless through Defold's build tool.

Why it mattersA small first download keeps players from bouncing, and a wide automatic test net is what lets a small team, or its agents, change code quickly.

headless
Run without a screen or window, so tests can run on a build server.

Sources Defold: Creator spotlight, Snowfall Games

More like this Less like this

Learn one thing

What is prompt caching?

Prompt caching lets a model provider reuse the work it already did on the start of a request. When the next request begins with exactly the same text, that part is billed at a fraction of the price and answered faster.

Think of it like thisIt is a reader who keeps a bookmark: if you hand over the same book again, they skip straight to the new chapter instead of rereading from page one.

Agents send the same long beginning on every turn: instructions, tool definitions, earlier messages. The provider stores its processed form of that prefix. If the next request matches it exactly, the stored part is read back instead of recomputed, which is why prices list cached input separately (Hydrogen's is $0.075 per million tokens against $1.50).

The match must be exact, so one changed character near the top, such as a timestamp or keys in a different order, breaks it. Nothing errors when that happens; the bill just stays high. Today's research entry found that 90% of such mistakes in open-source agent apps fail silently.

Only an identical prefix is reused. Put anything that changes (dates, IDs, the new question) after it.
prefix
The opening part of a request, which stays the same from one call to the next.

Try this today

Software and AI 30 minutes For practitioners

Check that your agent actually hits the prompt cache

Find out in a few minutes whether your app pays full price for text it sends on every call, and fix the most common cause.

You needAn app or script that calls a model API with prompt caching turned on, and access to the response's usage numbers.

  1. Send it twice

    Make the same request twice in a row, a few seconds apart, and log the usage block of each response.

  2. Read the counts

    On the Claude API, the second call should show most of the prefix under cache_read_input_tokens. If it shows zero, the prefix changed between calls.

  3. Hunt the change

    Look above the cache marker for anything that varies: timestamps, request IDs, random ordering of JSON keys or tools, or a marker placed after changing content. These are the patterns the paper found most often.

  4. Move and re-run

    Move changing values below the marker, sort keys when you serialise, and repeat the two calls.

You know it worked whenThe second call reports most of the prefix as cache-read tokens, and your daily input cost drops on the next real run.

For youRun it on the SaaS backends that call Claude with long system prompts, and on the radar routine's own scripts if they call the API directly.

cache marker
The point in a request (on the Claude API, a cache_control field) that tells the provider how far the reusable prefix extends.

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

Most broken prompt caching fails silently, and a linter can find it

Silent and Costly: Characterizing and Detecting Prompt-Caching Mis-Integration in LLM AgentsYing Zhang, Ruoqi Guo, Yi Liu, et al.

Three-panel overview: the empirical study (10 agent apps, 148,947 pull requests, 120 mis-integrations, 90% silent), the CacheLint pipeline with an LLM guard check and dated oracle, and evaluation results with 0.86 precision and an ablation.
Image: Zhang et al., CC BY 4.0
The problem
Prompt caching cuts the price of repeated input sharply, but integrating it is fiddly, provider rules keep changing, and when it breaks nothing errors: the app just pays full price.
The idea
The authors went through 148,947 merged pull requests in 10 open-source agent apps, found 120 caching mistakes and sorted them into patterns, such as a timestamp in the cached prefix, unstable JSON ordering or miscounted cache usage. They then built CacheLint, which combines code queries, a dated table of what each provider supports, and a model that double-checks each finding.
The result
90% of the mistakes failed silently. CacheLint scored 0.71 precision and 0.78 recall on the labelled set, and 0.86 precision across 571 other agent projects, where it found 32 real problems. Developers confirmed 21 findings and merged 18 fixes, one in Anthropic's official SDK. Without the double-check, precision fell to 0.31.
Use it
Treat the paper's patterns as a review checklist for any code that calls a model: nothing that changes above the cache marker, stable key order, and a log line for cache-read tokens so a silent miss shows up.

For youRun the checklist over the SaaS services that send long system prompts and over any routine scripts that call the API.

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