No. 34 Monday 16 November Game dev, software and AI

Every bug comes with a test

Researchers let a coding agent prepare Python web apps for a bug-proving tool, then made it back every finding with a test: 1,050 bugs in 11 apps. Plus Uber's guard rails for agents, a shorter disclosure clock, and engine shares on the move.

The short version

  • Software and AI An agent wrote the contracts and a fake database so the solver CrossHair could run on 81% of functions instead of 4.5%. All 1,050 bugs it reports in 11 apps come with a reproducing test.
  • Software and AI Uber described how it guards its AI agents: a registry of what each agent may do, checks at every tool call, and a shadow mode to tune false blocks before turning enforcement on.
  • Games and software Google Project Zero now publishes bugs 90 days after reporting, with no extra month for patches to spread, and moves to 60 days in February and 30 in January 2028, citing AI-speed exploitation.
  • Game dev GDC's November survey: Unreal is still the most used engine at 35%, down from 42%. In AAA, in-house engines (53%) passed Unreal (41%), as reported by Automaton.
  • Game dev PixiJS now does 3D too: an open beta where a 3D view sits inside a 2D stage, built for WebGPU with a WebGL2 fallback, MIT licensed.
Software and AI Lesson

The agent sets up, the solver hunts, a test proves it

Researchers paired a coding agent with a tool that mathematically searches for crashing inputs. The agent did the setup work people usually skip, and every bug it reported had to come with a test that reproduces it.

ContextCrossHair is an open-source Python tool that explores a function's possible inputs to find ones that break its stated rules; it has rarely been used on real web apps because it needs hand-written rules and cannot talk to a real database.

The five stages of the pipeline, as described in the paper. Only the solve step is free of AI; only bugs with a passing reproduction test are reported.

The team from Chalmers University of Technology and the University of Edinburgh built a fixed pipeline around Claude Code. First the agent writes stand-ins for the database calls, so the solver can run without a real database. Then it writes contracts, statements of what each function expects and promises, for the riskiest functions. CrossHair then searches each function for inputs that break them, with no AI involved.

A second agent sorts every finding into real bug, bad contract or setup artifact, and each real bug must be reproduced by a unit test, and where possible by an end-to-end test on the unmodified app. Across 11 open-source Python web apps, including Zulip, NetBox and Apache Superset, with over 1.1 million lines, the setup let CrossHair run 81% of 5,406 contracted functions, against 4.5% without it.

The pipeline reported 1,050 reproduced bugs: 221 found by CrossHair and the rest flagged while the agent wrote contracts. A baseline where the same model simply read the code found more in total but missed 312 of these. CrossHair's finds were mostly crashes on odd but allowed inputs, such as empty strings, missing fields and unusual characters; the reading baseline mostly found wrong outputs.

1,050bugs, each reproduced by a test, in 11 Python web apps

Technical details

The paper is arXiv 2611.15596 by George Granberry, Wolfgang Ahrendt, Andrew D. Gordon and Moa Johansson. The harness ran Claude Opus 5.5 through Claude Code. Stubs are repaired up to two times against a checking script; up to 800 risk-ranked functions per repository get contracts; CrossHair gets 30 seconds per condition.

Of the 1,050 bugs, 920 were reproduced end to end. Framework set-up alone (without the synthesized database stand-ins) let CrossHair run 29.5% of functions. One author blind-reviewed 50 bugs from each method and judged 72% and 70% real, not a significant difference.

Limits the authors list: a single run, no maintainer review yet, one reviewer, and only Django and SQLAlchemy apps. LLM cost was estimated at no less than $2,821 for the pipeline across 11 repositories against about $712 for the reading baseline, priced rather than billed.

Why it mattersAgents that report bugs tend to report some that are not real. Requiring a reproducing test for each one, and pairing the agent with a tool that searches exhaustively, is a pattern any team can copy without this paper's code.

For youThe witness-test rule fits a review subagent on the Node and Supabase SaaS work today: no bug claim lands without a failing test. CrossHair itself only covers Python, so the transferable part is the stub-plus-contract setup and the evidence rule.

contracts
Statements attached to a function about what inputs it accepts and what it promises to return, which a tool can check.
end-to-end test
A test that drives the whole running application the way a user would, instead of calling one function directly.
deterministic
Gives the same answer every time for the same input, with no randomness or guessing.

Sources arXiv: Bug Finding With Agentic Symbolic ExecutionCrossHair on GitHubArtifact on figshare

More like this Less like this

Agents in production

Guard rails, a shorter patch clock, traces an agent can read, and a throughput cliff.

Software and AI Lesson

How Uber keeps its AI agents inside the lines

Uber published how it secures the AI agents its teams build: every agent is registered with what it is allowed to do, every action is checked as it happens, and the checks are tuned in shadow mode before they block anything.

Three layers, from before an agent ships to after it runs, as described by Uber's engineers.

Uber's stated lesson: limiting each agent to explicit intents did the most to stop manipulated instructions, at a cost in flexibility. The post gives no figures for false blocks or latency.
Technical details

Names in the post: Uber AI Registry holds identity, ownership, persona and permitted intents; AI Guard is the policy decision point; Agent Guard hooks enforce at agent and tool-execution boundaries; Argus is the automated analysis platform. Runtime checks use smaller specialised models and run in parallel to stay inside latency budgets.

Rollout: shadow mode to measure false blocks and false allows against real traffic, replay of recorded traffic to test policy changes, then per-agent calibration before enforcement is switched on.

Why it mattersIt is a rare detailed account of agent security at scale, and its main finding, narrow permissions beat clever detection, applies to a single developer's agent setup as much as to Uber's.

For youClaude Code hooks and permission rules are the small version of Agent Guard: a PreToolUse hook in log-only mode for a week is the shadow mode, before it starts blocking.

intents
The specific kinds of actions an agent is allowed to take, written down in advance.
shadow mode
Running a check on real traffic and logging what it would have blocked, without actually blocking anything.

Sources Uber Engineering: Securing AI agentsInfoQ summary

More like this Less like this

Games and software News

Bug disclosure gets a shorter clock

Google's Project Zero, which finds security holes in other companies' software, will publish its findings sooner after telling the vendor, because AI now helps attackers turn a patch into an exploit fast.

The old rule, used since 2021, was 90 days to fix plus 30 days for the fix to spread.

  1. Full 90: details published 90 days after the report, fixed or not, with no extra 30 days.

  2. Full 60.

  3. Full 30.

Technical details

The grace period and variant policy are also gone. Exceptions remain for bugs exploited in the wild, bugs already public, vendor requests and some hardware cases. The team says it now finds several vulnerabilities a week in targets where it once found a few a year.

Why it mattersFixes in the libraries and engines you depend on will become public sooner after they ship, so the time to update shrinks.

For youWorth turning on automatic dependency update pull requests for the SaaS repositories if they are not on already.

Project Zero
Google's team of researchers who look for serious security holes in widely used software.

Sources Project Zero: Policy and Disclosure, 2026 Edition

More like this Less like this

Software and AI Release

Background workers on Vercel can now hand their traces to an agent

Vercel's background workers can now record what they did, step by step, and a command-line search returns those records as data a coding agent can read.

Register tracing before the worker starts, then query its spans from the terminal.

// worker.ts
import { registerOTel } from '@vercel/otel';

registerOTel({ serviceName: 'my-daemon' });

// terminal
// vercel traces search \
//   --project my-project \
//   --service my-daemon --json

With @vercel/otel 2.3.0 or later, Node.js daemons export traces automatically through a socket Vercel provides.

The JSON output is meant for agents: one can read the slowest spans of a production worker without a dashboard.

Technical details

The socket path is in the environment variable VERCEL_OTEL_SOCKET_PATH and accepts OTLP over HTTP. The changelog gives no performance figures.

Why it mattersGiving an agent the same production evidence a person would look at is what turns 'fix the slow job' into a task it can check its own work on.

For youFits any queue worker in the SaaS projects that runs on Vercel; a skill that runs the search command gives Claude Code production timings on demand.

traces
Records of each step a program took while handling a job, with timings, used to find what was slow or failed.
spans
The individual timed steps that make up a trace.
daemons
Programs that run in the background, such as queue workers, instead of answering web requests.

Sources Vercel changelog: daemons send traces

More like this Less like this

Software and AI Lesson

Self-hosting a giant open model: more users help, then hurt

NVIDIA ran a very large open model on two desktop workstations and measured how many words per second it produced as more people used it at once. Output rose up to 16 users, then fell.

Total output for GLM-5.3 split across two DGX Stations, by requests in flight at once (vendor-reported).

At 32 requests each user got 13 tokens per second against 115 alone, and an average request took 454 seconds. Coding benchmark from NVIDIA's own post.

Technical details

Setup: GLM-5.3 (753B parameters, 40B active per token) in a 4-bit NVFP4 checkpoint of about 464 GB, split over two GB300 GPUs with 252 GB each, linked by ConnectX-8 RDMA, served with vLLM, an FP8 key-value cache, prefix caching and 4-token speculative decoding, with a 98,304-token context limit.

Why it mattersIf you serve a model yourself, the busiest setting is not the fastest one: past a point, extra concurrent requests make everyone wait longer for less.

For youUseful only as a reference for running agents against a local model; the hardware is far beyond a studio workstation.

tok/s
Tokens per second, roughly how many word pieces a model writes each second.
open model
A model whose weights anyone can download and run on their own hardware.

Sources NVIDIA: Serving GLM-5.3 across two DGX Stations

More like this Less like this

Engines on the move

Who uses which engine now, what Unreal 5.9 changes on screen, and 3D in a 2D library.

Game dev Trend

Unreal still leads, but its share fell seven points

A new survey of over 2,600 game developers shows Unreal Engine is still the most used engine, but fewer studios use it than at the start of the year, and big studios now favour engines they build themselves.

GDC's State of the Game Industry, November 2026 edition, against the previous one.

Previous survey November 2026
Unreal, all respondents 42% 35%
Unity, all respondents 30% 28%
In-house engines, all 19% 23%
AAA studios: in-house 44% 53%
AAA studios: Unreal 47% 41%

AAA moved in-house; AA and indie studios still mostly pick Unreal (about 40 to 50%), and the youngest indie studios lean toward Godot.

Technical details

The survey ran from mid-August to September 11, 2026, across 69 countries, with a stated margin of error of 3 points. The previous edition came out on January 30, 2026, so the comparison spans less than a year. The AAA split comes from Automaton's reading of the report; the report does not say whether heavily modified Unreal or Unity counts as in-house.

Other findings: Godot is at 6% overall; 40% of respondents use generative AI at work and 55% think it hurts games, against 54% last time.

Why it mattersEngine share decides where tools, plugins and jobs are; a drop like this is worth watching even though Unreal still leads by seven points.

For youFab buyers follow Unreal's share; the AA and indie segment (still 40 to 50% Unreal) is the plugin market, and AAA going in-house matters less to it than the Godot drift among new studios.

AAA
The largest, most expensive game productions, usually from big publishers.
in-house engines
Game engines a studio builds and maintains for its own games instead of licensing one.

Sources Automaton (Japanese): GDC survey on enginesGamesBeat: GDC survey

More like this Less like this

Game dev Trend

Puzzle makers pick Godot

Two separate counts point the same way: small and new teams, especially puzzle game makers, are choosing the free, open-source Godot engine.

30%of Thinky Awards nominees made in Godot (17 of 59)

14%of the newest indie studios use Godot (GDC survey)

The awards count is an informal tally by a Godot maintainer, excluding pen-and-paper entries.

Why it mattersPuzzle games are where solo and tiny teams often start, so this is an early read on which engine the next wave of developers learns first.

Thinky Awards
Yearly awards for puzzle and other 'thinky' games, run by the Thinky Games community.

Sources Rémi Verschelde on BlueskyAutomaton: GDC survey

More like this Less like this

Game dev Release

Unreal 5.9 Preview: the rendering changes behind the agent news

The Unreal Engine 5.9 preview was covered for its AI agent tools, but it also changes how lighting, glass and foliage work, and some of it applies to existing scenes automatically.

From Epic's preview release notes, updated November 9. Preview builds are for testing, not shipping.

  • Lumen World Cache

    Lumen builds its lighting cache by path tracing the scene at runtime instead of from per-mesh cards, so no card fix-ups. Needs hardware ray tracing; enabled per project.

  • Order-independent transparency

    Overlapping glass, smoke and other see-through surfaces blend correctly whatever order they draw in, ending sorting pops.

  • Smarter Nanite culling

    Simple and complex instances, such as skinned meshes, are handled separately. Existing scenes benefit with no content changes.

  • Dynamic Wind

    An experimental plugin that moves foliage and skeletal plants in the wind, simulating each bone on the GPU.

Technical details

Also in the notes: IK Retargeter gains three spatially aware operations; Control Rigs can be referenced as assets; a UAF AnimGen plugin and an NVIDIA Kimodo plugin add AI-guided animation; PCG adds a Concave Hull node. Translucent materials must output only their own colour for the new transparency to composite correctly.

Why it mattersThese are the changes most likely to survive into the full 5.9 release next year, and the transparency and culling work touches nearly every 3D project.

For youCheck the plugins' translucent materials (VFX, interaction highlights) against the new transparency rule in a 5.9 Preview copy before 5.9 ships.

Lumen
Unreal's system for real-time global illumination, the light that bounces off surfaces onto other surfaces.
path tracing
Simulating light by following many rays as they bounce around a scene; accurate but costly.
Nanite
Unreal's system for drawing very detailed meshes by streaming only the detail the camera can see.
culling
Skipping objects the camera cannot see so the GPU does not draw them.

Sources Epic: Unreal Engine 5.9 Preview release notes

More like this Less like this

Game dev Release

PixiJS 3D

A 3D engine for the browser that drops into a PixiJS 2D app as one display object.

PixiJS, a widely used library for 2D graphics and games in the browser, released an open beta of a 3D engine; a 3D scene behaves like any other object in a 2D game, so menus, effects and clicks keep working.

A dark graveyard seen from above, with a glowing hero surrounded by hundreds of skeleton enemies, a timer reading 02:57, a kill count of 1,695 and a row of ability icons.
Image: PixiJS, Nightward demo

It targets WebGPU first and falls back to WebGL2 with the same code. The team's demo draws 100,000 objects with shadows at 60 frames per second, and 100 crates in 100 colours in a single draw call.

Status
Open beta, November 12
Needs
pixi.js 8.23.0 or later
Licence
MIT

Try itnpm install pixi.js @pixi/3d

Technical details

Instancing and batching come through BatchedMesh3D; twelve animated characters from one model draw in one call. Culling runs in a compute shader on most WebGPU browsers and on the CPU on Safari and iOS. A pixijs-3d agent skill ships for Claude Code, Cursor, Codex and Copilot. The figures are the PixiJS team's own demos.

Why it mattersWeb games that are mostly 2D can now add 3D scenes without a second engine and its separate input and UI layers.

For youA direct comparison point for the three.js browser games: worth one evening to see whether a 2D-first game with a 3D scene is simpler in PixiJS.

WebGPU
The newer browser interface for talking to the graphics card, faster and more flexible than WebGL.
draw call
One instruction from the program to the graphics card to draw something; fewer calls usually means faster frames.

Sources PixiJS blog: PixiJS 3D open beta

More like this Less like this

Learn one thing

What is symbolic execution?

A way of testing code by running it with stand-in values instead of real ones, so a tool can work out which exact inputs would send the program down each path, including the ones that crash it.

Think of it like thisInstead of trying keys on a lock one by one, you study the lock and work out the shape of the key that opens it.

The tool treats each input as an unknown, like x in algebra. Every if statement splits the run into two paths and adds a condition, such as 'x is empty' or 'x is not empty'. A solver then finds real values that satisfy each path's conditions, so it can hand back a concrete input that reaches a crash or breaks a stated rule.

It is thorough where random testing is lucky, but it struggles when code talks to the outside world, such as a database, and it needs to know what 'wrong' means. Today's lead uses an agent to fill both gaps: it fakes the database and writes the rules.

Symbolic execution in one line: turn inputs into unknowns, collect the conditions on each path, and ask a solver for values that reach the bad ones.
solver
A program that finds values making a set of logical conditions true, or proves none exist.

Try this today

Game dev 45 minutes For practitioners

Drop a 3D scene into a 2D PixiJS game

Find out in under an hour whether a browser game that is mostly 2D can carry a 3D scene without bringing in a second engine.

You needA PixiJS app on version 8.23.0 or later (or a fresh one), and a coding agent if you want the skill.

  1. Install

    Add the 3D package next to PixiJS. It needs pixi.js 8.23.0 or later.

  2. Give the agent the docs

    Install the PixiJS skills, which include a pixijs-3d skill, so Claude Code, Cursor, Codex or Copilot write against the real API.

  3. Add one View3D

    Add a View3D to your existing stage with one model or a few shapes, then put a 2D sprite or button on top of it.

  4. Push it

    Swap the shapes for a BatchedMesh3D of a few thousand copies and watch the frame rate in the browser's performance tools.

npm install pixi.js @pixi/3d
npx skills add https://github.com/pixijs/pixijs-skills

You know it worked whenThe 3D view renders inside the 2D stage, the 2D button on top still takes clicks, and the batched scene holds a steady frame rate on your target devices.

For youTry it on the smallest of the browser games, where a 3D board or map inside a 2D UI would otherwise mean three.js plus a separate HTML layer.

View3D
The PixiJS object that holds a 3D scene and can be placed in a 2D stage like a sprite.

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 PaperNeurIPS 2026 Workshop on Interpreting Agent Behavior (arXiv 2611.17440)

Agents with the same pass rate work in very different ways

Interpreting Coding Agents Through Their Behavioral TrajectoriesIbragim Badertdinov, Alexander Golubev (Nebius)

A chart of six workflow measures, such as operational actions and test invocations, showing how far 60 matched agent pairs differ on each, and how many pairs each measure separates.
Image: Badertdinov and Golubev, arXiv
The problem
Coding agent leaderboards report only whether a task was solved, hiding how much the agent searched, edited and tested along the way.
The idea
A rule-based parser turns raw agent logs into plain actions (search, read, edit, run tests) and profiles each agent on six workflow measures, across 143,209 runs from 125 agent setups and 117 models.
The result
All 60 pairs of agents matched on scaffold and solve rate (within 1 point) differed on at least two of six measures. Profiles alone picked the exact agent setup 85.1% of the time out of 111, against 0.9% by chance. Raising effort took Claude Opus 4.8 in Claude Code from 31.3 to 54.4 actions per task.
Use it
Run the released parser on your own agent transcripts to compare settings or skills by the reads, edits and test runs they cost, not only by whether they passed.

For youFits comparing two Claude Code skill or effort setups on the same plugin task: count test runs and edits, not only green or red.

More like this Less like this

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

ReadarXiv: 2611.17440Code: trajectory-analyzerData on Hugging Face

Game dev PaperACM paper (DOI 10.1145/3842564), preprint arXiv 2611.08665

Sparse voxel grids on the GPU can now change shape in milliseconds

Dynamic GPU Voxel Grids and Voxel-sequential Processing in NanoVDBEftychios Sifakis, Francis Williams, Christopher Horvath, et al. (NVIDIA, University of Wisconsin-Madison)

Three panels: a sphere of hair strands voxelized, a billowing blue smoke simulation, and colour-coded 3D maps of rooms built from sensor scans.
Image: Sifakis et al., arXiv
The problem
NanoVDB, the GPU version of the film industry's standard format for smoke, fluids and volumes, could only be read, so anything that grew or changed had to be rebuilt on the CPU.
The idea
Bit-parallel GPU operations to grow, merge, prune and change the resolution of a grid, plus a way to stream active voxels as a flat list instead of walking the tree.
The result
NVIDIA-reported on one RTX 6000 Ada: a 2.8-million-triangle mesh became about 1 billion voxels in 2.3 s against 23.9 s for OpenVDB; growing a 567-million-voxel grid took 2 ms, 76 times faster than OpenVDB's CPU code, in 356 MiB instead of 48 GiB.
Use it
For editor-time volume work (fog and smoke bakes, voxel or distance-field world tools, large fluid sims), try NanoVDB or fVDB instead of CPU OpenVDB rebuilds.

For youRelevant to a world-tools plugin that bakes volumes or distance fields offline; less so to runtime gameplay code.

More like this Less like this

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

ReadarXiv: 2611.08665Code: OpenVDB (NanoVDB)Code: fVDB

Game dev PaperSymposium on Computer Animation 2026, Computer Graphics Forum (arXiv 2611.18253)

A small network predicts a cartoon character's cloth folds from its pose

Pose-based Neural Clothing for Animated CharactersJulian N. Heidenreich, Vinicius C. Azevedo, Jakob Buhmann, et al. (DisneyResearch|Studios, ETH Zurich, Pixar)

A three-stage training diagram: a shirt mesh through an encoder and decoder, progressive training on staged shirts with a local wrinkle loss, and pose-conditioned training from joint transforms and body displacements.
Image: Heidenreich et al., arXiv
The problem
Cloth simulation is slow and fiddly, and neural cloth methods trained on realistic human bodies break on stylized characters in poses they have not seen.
The idea
Train an autoencoder for a smooth space of garment shapes, then gradually retrain its encoder to predict the shape from the pose and body surface, with a loss that keeps wrinkles sharp. One garment, no secondary motion.
The result
On a production character, error was 0.36 for the shirt against 0.47 for Maya 2025.2 and 0.76 for Unreal Engine 5.6 cloth, and 0.08 for pants against 0.21 and 0.25. It runs about 1,200 times a second on an RTX 4070 Ti, similar to other neural methods.
Use it
Evidence that per-character neural cloth can stand in for runtime cloth on stylized rigs where a static look is acceptable. No code yet, so watch for one.

For youWorth watching for the action RPG's stylized characters; it compares directly against UE 5.6 cloth.

More like this Less like this

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

ReadarXiv: 2611.18253

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