No. 7 Tuesday 20 October Game dev, software and AI

Cloudflare cut its AI review bill by two thirds and kept the findings

One team's code-review agents went from $2.43 to $0.77 a review by fixing caching, trimming tools and choosing models by test. Also: Meta's deliberately dumb orchestrator, skills that crowd each other out, and studios hiding demos from cloners.

The short version

  • Software and AI Cloudflare's multi-agent code reviewer now costs $0.77 a review, down 68%. Most of the drop came from cache hits, fewer tool calls and model choices tested on real reviews.
  • Software and AI Meta keeps its agent router deliberately thin: 1,300 lines, seven fixed steps, and only one step that asks a model anything.
  • Software and AI Load two agent skills for the same job and models follow one and quietly drop the other: rule adherence fell from 93-99% to about 61% in a new benchmark.
  • Game dev The studio behind Moonlighter swapped a public playtest for a closed Discord test, citing games cloned before launch, as Steam Next Fest runs to October 26.
Software and AI Lesson

Cloudflare cut its AI code review bill by 68%

Cloudflare runs a team of AI agents that reviews its engineers' code changes. Over a few weeks it cut the average cost per review from $2.43 to $0.77, and checked that the useful findings did not go away.

Line chart of weekday cost per review, September 7 to October 6: it falls from about $2.45 to $0.75, with eight numbered changes marked, from a shared cached prefix to the Sonnet 5.5 rollout.
Image: Cloudflare

The reviewer is several agents: a coordinator that hands each code change to specialists for code quality, security, performance, documentation and compliance. Costs had crept up from $1.19 a review in April to about $2.46 by late August, so one engineer went through the bill line by line.

The biggest single fix was caching. Every reviewer's first request now starts with the same block of tool definitions and shared rules, so the provider can reuse it instead of charging full price again. Then came a series of small cuts: removing tools reviewers could not use, skipping reviewers on re-reviews that did not need them, stopping as soon as the review was posted, and killing cancelled jobs that kept running.

Model choices were tested, not assumed. A split test found the newer mid-size model 47% to 62% cheaper per run, so all those reviewers moved to it. Of the $1.67 saved per review, $0.65 came from code changes and $1.06 from model and effort settings.

$0.77average cost per review, down from $2.43

Technical details

Cost history as reported: $1.19 per review in April, about $2.46 by late August, $2.43 averaged over the two most expensive weeks, $0.77 now. Median review time fell from 4m 09s to 1m 32s. The shared cached prefix (September 16) took cost per review from $2.47 to $2.02 on its own; the call-trimming changes of September 21 to 23 saved about $0.20 more, including about $0.07 per job from stopping once the review is posted.

Three sub-reviewers share one first request: the first writes the cache and the other two wait up to 20 seconds to read it, saving about nine cents per reviewer. The coordinator moved to Opus 5.5 at medium effort; Sonnet reviewers moved from Sonnet 5 to Sonnet 5.5 after a split test; code quality runs at high effort, adding about two cents per review. The reviewer runs on OpenCode v2.

Quality checks: a finding counted as acted on if its flagged lines changed in the author's next push (a baseline of nearby lines changed about 15% of the time). Serious code quality findings acted on rose from 34% to 59%. Two models from different providers judged 657 findings blind: important findings per review went from 0.28 to 0.30, and findings judged too severe fell from 0.46 to 0.14 per review. Medium effort did lose real performance findings (about 64% fewer important ones), and the author notes the before and after steps are not a controlled experiment.

Why it mattersAgent pipelines in CI are billed per token, and most of that bill is often re-sent context. Measuring whether the first request hits the cache, then testing cheaper settings against a quality metric, is a playbook any team can copy.

For youThe same levers apply to your routines and subagent-heavy sessions: put the stable rules and tool list first, drop tools a subagent never uses, and check cache reads on the first request in your API usage before touching models.

caching
Reusing the start of a request the model provider has already processed, which is billed at a fraction of the normal price.
split test
Sending a random half of real jobs to each option and comparing the results, so the difference comes from the option and not the jobs.
effort
A setting that controls how much a model thinks before answering; more effort costs more tokens.

Sources Cloudflare: Cutting our inference bill by 68%

More like this Less like this

Agents that run lean

A router that barely thinks, a cheap grader tuned well, and skills that crowd each other out.

Software and AI Lesson

Meta made its agent router dumber, and the agents got more reliable

Meta built a system of 14 specialist AI agents for data pipeline work, and found it worked best when the program that routes work between them does almost no thinking itself.

The orchestrator is about 1,300 lines and runs a fixed seven-step protocol for 20+ kinds of request. Six steps are ordinary code; only the hand-off asks a model to reason. Domain knowledge lives in 25+ files the specialists load when they need them.

The seven-step protocol from Meta's write-up, with steps 1 to 4 folded into one box. Workflow templates decide which specialists run in which order.
Technical details

Results Meta reports: preparing the configuration for a new data column took three to four days by hand, about a day with the earlier config-driven system, and under an hour now. About two thirds of changes land without significant human edits. A results table lists about 70% success without per-task prompt engineering, a production revert rate of about 0.2%, 1,282 code changes landed and 1,384 columns processed.

Why not one agent: Meta says a single agent's accuracy fell as its context grew, because it confused conventions across subsystems. A single-agent design reached 70% to 80% success only with a custom prompt for each task, and 10% to 20% without. The post cites a separate preprint that measured 65.3% accuracy for orchestrated agents against 16.6% for a single agent on 80-task batches.

Workflow templates are state machines: column onboarding has four phases, event onboarding and pipeline migration five each. A column can touch up to six pipeline stages across three repositories, with Python configs that drive C++ code generation.

Why it mattersWhen one agent holds every rule for a big system, it starts mixing conventions up. Keeping the router as plain code and pushing knowledge into small, separately loaded specialists is a pattern any agent setup can borrow.

For youThis maps directly onto skills and subagents: a thin top-level command that only routes, specialist subagents with their own instruction files, and knowledge in files loaded on demand. Pipeline migration was added as a new template with no new agent code.

orchestrator
The program that receives a request, decides which agent should handle each part, and collects the results.
context
Everything a model can see while it works: instructions, files and earlier messages.
workflow templates
Fixed sequences that say which specialists run, in what order, for a kind of request.

Sources Meta Engineering: The Thin Orchestrator

More like this Less like this

Software and AI Lesson

A cheap grader can stand in for a big one, if you tune it

Hamel Husain and Antaripa Saha tested small yes-or-no classifier models as graders for AI outputs, and found the cheapest one close behind at a fraction of the price once its cut-off was tuned.

0.87F1 score of the best grader on 98 labeled traces

4.5xcheaper for the runner-up, at F1 0.79

The default pass mark of 0.5 can be badly wrong; they pick it per model with cross-validation, then check whether the scores match real failure rates. The dataset is small, so treat it as a method, not a ranking.

Technical details

Numbers from the post: OpenAI Decisions (GPT-6 Luna) reached F1 0.87 at 3.72 cents per 100 runs; Perplexity Decider 1.1 27B reached 0.79 at 0.82 cents. They set a floor of 80% precision and recall, used stratified 5-fold cross-validation with the same splits for every model, and tried Platt scaling for calibration, which helped some models and slightly worsened OpenAI's Brier score (0.159 to 0.164).

Why it mattersAutomated graders run on every change, so their price adds up. Tuning the threshold costs no new model calls and can make a cheaper grader good enough.

For youIf you grade agent output with a model in CI, save the scores once and sweep the threshold before paying for a bigger judge.

F1 score
A single number from 0 to 1 that balances how many real failures a grader catches and how many of its alarms are real.
threshold
The score above which the grader's answer counts as a fail.
cross-validation
Testing a choice on several held-out slices of the data so it is not tuned to one lucky sample.

Sources Hamel Husain: How to use decision models for evals

More like this Less like this

Software and AI Lesson

Two skills for one job: the agent follows one and drops the other

Researchers loaded two instruction packs written for the same task into AI models and found the models usually obeyed one pack fully and silently ignored the other, even when the rules did not conflict.

Bar chart: seven models follow about 93 to 99 percent of a skill's rules alone or beside an unrelated skill, and about 61 percent beside a second skill for the same job. Heat maps show one skill's rules winning.
Image: Razmara et al., arXiv 2610.25064

Agent skills are packaged instructions that people share and install, so two written by different authors for the same job, say commit messages, can easily load together. The SkillClash benchmark tested 16 such pairs, each skill with six checkable rules and one worked example, on seven models from 4B open models to GPT-4.1.

A skill alone was followed 93% to 99% of the time. Add a second skill for the same job and adherence fell to about 61%, mostly as takeover: one skill's rules all kept, the other's all dropped. An unrelated second skill changed nothing. Telling the model which skill wins did not bring the dropped one back.

  • The worked examples drive it: an example that follows both skills cut takeover to 1% to 15% on six models.
  • One merged skill file reached 96% to 99% of achievable rules on all seven models.
  • The test skills were written for the benchmark; a reanalysis of real-skill data shows a smaller effect of about 8 points.
Technical details

SkillClash (arXiv 2610.25064, submitted October 18) by Parsa Razmara, Seyedarmin Azizi and Ardalan Aryashad. Models ranged from Qwen3-4B and Phi-4 mini to Qwen3-235B and GPT-4.1. An "apply both" instruction helped only the two strongest models, and only about 21% to 22% of their outputs were fully correct. The merged file was written by Claude Opus 5.5; 68% to 94% of outputs with it were fully correct, and much of the gain came from its single worked example, which helps only when the example itself is right. Code is on GitHub.

Why it mattersAs teams install skills from many sources, overlaps are easy to miss, and the failure is silent: the output looks fine but half the rules are gone.

For youCheck your global and project skills for pairs that cover the same job, such as commit messages or PR descriptions, and merge them. Today's Try this walks through it.

agent skills
Folders of instructions and examples an AI agent loads when a task matches them.
worked example
A sample input and the ideal output, included so the model can copy the pattern.
takeover
The paper's name for when one skill's rules are all followed and the other's are all dropped.

Sources arXiv: One Skill Takes OverSkillClash code

More like this Less like this

Tools to update, text to doubt

A coding agent release, hidden notes for chatbots, and a GitHub change that can break builds.

Software and AI Release

Claude Code 2.1.304: a security check for hosted agents and a safer worktree exit

A large update to Anthropic's coding agent adds a command that checks hosted agent settings against Anthropic's security guide, fixes a way work could be lost on exit, and warns before costly session resumes.

Version 2.1.303 was bug fixes only. Version 2.1.304, released October 19, is the one to read.

  • Security check for Managed Agents

    /claude-api managed-agents-secure compares a hosted agent's settings with Anthropic's published security guide and lists the differences. It changes nothing.

  • Worktree exit no longer deletes your branch

    claude --worktree used to remove the worktree and its branch without asking at exit when the checkout was detached or on another branch, which could lose commits.

  • Guided auto mode setup

    /auto-mode-setup reads your project and recent sessions to teach auto mode about your environment, now also on Bedrock, Vertex and Foundry.

  • Warning before an expensive resume

    Pro and Max users are warned when resuming an idle conversation would use a noticeable share of the 5-hour limit, and can start fresh instead.

  • Prompt before deleting mounted drives

    Recursive deletes of top-level or mounted folders such as /Volumes, /media or WSL's /mnt/c now ask first.

  • Compaction window values fixed

    CLAUDE_CODE_AUTO_COMPACT_WINDOW=200k used to silently mean 100K. It now accepts k and M and warns about values it ignores.

Technical details

Other changes in 2.1.304: tool search is on by default behind a custom ANTHROPIC_BASE_URL and retried without it on a 400 or 422; context_management errors behind LLM gateways are fixed by resending without that field; compaction now resends the skill list, and /reload-skills sends only new or changed skills; skill hooks are limited to 1,024 hooks and 16,384 matcher characters per session per source; /fast lost its research preview label on Opus 5.5; bracket globs in sandbox.filesystem.denyRead no longer break sandboxed commands on Linux; throughput improves with many subagents running.

Why it mattersTwo of these protect work you could otherwise lose without noticing: commits in a worktree branch and files on a mounted drive. Updating is worth it for those alone.

For youRun the managed-agents-secure check on any hosted agent you deploy, and set the compaction window again if you used a k value. Self-paced /loop wakeups at the one-hour maximum also stop landing just after the prompt cache expires.

worktree
A second working folder for the same git repository, so an agent can work on a branch without touching your main checkout.
Managed Agents
Anthropic's hosted service that runs agents in its own cloud sandboxes.
compaction
Summarising older parts of a long conversation so it fits in the model's context.

Sources Claude Code v2.1.304 release notesClaude Code v2.1.303 release notes

More like this Less like this

Software and AI News

WhatsApp's help pages carried hidden notes for chatbots

A researcher found invisible text on 80 WhatsApp help pages telling AI assistants not to suggest contacting a regulator or citing privacy law. The notes vanished after press coverage.

Redact.dev read 545 WhatsApp help pages and found 102 hidden blocks of text on 80 of them. None turned up on 300 Facebook and Instagram pages checked. WhatsApp said they were chatbot instructions exposed by a bug.

  1. An archived copy of the pages shows no hidden text.

  2. The hidden notes are present in an archived copy.

  3. Redact.dev finds them, including advice not to cite GDPR even when the user does.

  4. Still live at 21:40 UTC.

  5. All 102 blocks are gone by 02:08 UTC, after WIRED covers the find.

Technical details

The author tested on October 9 whether the notes were served to OpenAI, Anthropic and Perplexity crawlers and found they did not appear to be. He did not test whether any assistant obeyed them. WhatsApp told reporters it wants chatbots not to offer legal advice.

Why it mattersAgents that read documentation also read whatever is hidden in it. Text aimed at one company's chatbot can steer anyone's assistant that fetches the page.

For youWorth a line in agent instructions for any SaaS support bot: vendor pages are data, and hidden text in them is not policy.

GDPR
The European Union's data protection law, which gives people rights over their personal data.

Sources Redact.dev: WhatsApp's hidden AI instructions

More like this Less like this

Games and software Do this

Anonymous clones from GitHub may start asking for a login

GitHub says that during unusual traffic it may require sign-in for cloning public repositories over HTTPS, so build scripts that clone anonymously could suddenly fail.

The change, posted October 19, covers unauthenticated HTTPS clone and fetch of public repositories. SSH, pushes and authenticated HTTPS are unaffected. GitHub gives no end date.

  1. Find anonymous clones

    Search CI configs, Dockerfiles and setup scripts for git clone https://github.com/ lines that pass no token.

  2. Use the built-in token in Actions

    Inside GitHub Actions, authenticate with the provided GITHUB_TOKEN; the checkout action already does.

  3. Use an app token elsewhere

    In other CI, GitHub recommends a GitHub App installation token, or a personal access token if you must.

  4. Know the symptom

    A clone that worked yesterday and now fails with an authentication error is this change, not a broken repo.

Why it mattersMany builds pull public dependencies straight from GitHub without credentials. They are the ones that will break, and only some of the time.

For youCheck the deploy workflows and any agent sandbox setup scripts that clone public repos anonymously.

CI
Continuous integration: servers that build and test code automatically on every change.
SSH
A secure way to connect to a server using a key pair instead of a password.

Sources GitHub Changelog: Git over HTTPS may require authentication

More like this Less like this

Games: demos, clones and craft

Next Fest opens, a studio holds its demo back, a ground texture from roots up, and a mobile hit still climbing.

Game dev Trend

Next Fest day one: a pawn shop sim leads the demos

Steam's week-long festival of free game demos opened October 19, and a pixel-art shopkeeping game had twice as many people playing as any other demo on its first night.

Players in each demo at once, in a snapshot taken at 1 a.m. Eastern on October 20 by Output Lag's live chart, idle games excluded. Valve publishes its own most-played list when the fest ends on October 26.

The fest keeps growing and each demo gets less: June's edition had 4,382 demos, up 66% on a year earlier, and the top tenth of games gained about 121 followers each, down from 163 (GameDiscoverCo data via Steam Page Analyzer).

Technical details

Probably Stolen is a cyberpunk pixel-art shopkeeper game from Montreal's Questing Goose Studio, published by tinyBuild, launching October 28. Valve's rules require games in the fest to stay unreleased until after it ends, with a public store page and a playable demo.

Why it mattersA demo's first two days shape where Steam shows it for the rest of the week, and the field is crowded. A snapshot like this shows how far ahead a well-prepared demo can get.

For youProbably Stolen ran a public playtest in August before the fest; that runway is worth copying for the action RPG's own Next Fest slot. The next edition is February 22 to March 1, 2027.

Next Fest
Steam's recurring week of free demos for unreleased games; each game may take part only once.

Sources Output Lag: Steam Next Fest live chartSteam Page Analyzer: Next Fest October 2026Probably Stolen on Steam

More like this Less like this

Game dev Trend

Studios start hiding demos from cloners

The studio behind Moonlighter scaled its next game's public playtest down to a closed Discord test, worried that AI tools let others copy a game before it ships.

With launch still months away, a large public build of ReVamp felt like too big a risk.

Digital Sun Games, studio behind Moonlighter

Digital Sun cited news of games being reverse-engineered, cloned and published before the original is out. Its closed test starts October 29. Game Developer reports developers describe feeding demos and trailers into AI tools to rebuild core features, and notes that game mechanics have little copyright protection.

Why it mattersPublic demos are how small studios get found. If showing a build means risking a copy that launches first, studios face a real trade-off between reach and protection.

For youBrowser builds are the easiest to lift whole. For the web games, think about what a public build exposes (source maps, unminified code, raw assets) before the next playtest.

Sources Game Developer: Moonlighter developer delays public playtest

More like this Less like this

Game dev Lesson

A forest floor material in 16 layers, roots first

An artist explained how they built a realistic, repeating forest floor texture in Substance 3D Designer, spending almost half the week on the tree roots alone.

Two spheres wrapped in the finished forest floor material: thick tree roots over soil, stones, moss, clover and dead leaves.
Image: Zeqi Mu via 80 Level

Zeqi Mu's breakdown for 80 Level took about a week. The order of work is the lesson: structure first, detail last.

  1. Build the roots first

    The first three days went into a root system made of splines scattered along other splines, which gave control over density and thickness.

  2. Stack layers bottom to top

    Sixteen layers: roots, stones from large to tiny, moss, dead leaves, twigs, clover, lichen, branches, grass, fallen leaves and ferns.

  3. Generate stones as shapes

    Stones come from a splatter node in distance-field mode with random roundness and facet count, so no two look the same.

  4. Take moss normals from its own layer

    Moss surface detail comes from its splatter, not the combined height, so it stays crisp on top of everything else.

  5. Keep big shapes sparse

    Low density on the main roots hides the repeat when the texture tiles across a large ground.

Technical details

Tools named in the breakdown: Scatter Splines on Splines (Cells 2 was tried and dropped for roots), multiplied Gaussian noises for height, Shape Splatter v2 in SDF mode. In Unreal Engine 5 the material uses Nanite displacement and a subsurface scattering mask on the clover leaves; Marmoset Toolbag was used for presentation.

Why it mattersTiling ground materials cover most of an outdoor scene. Fixing the large shapes before adding detail is what keeps the repeat from showing.

For youUseful reference for world-tool demo scenes: sparse large features are what hide tiling on big terrain.

splines
Smooth curves defined by a few control points, used here to draw roots.
tiles
Repeats seamlessly side by side, so one small texture can cover a large surface.
normals
Per-pixel directions that tell the renderer which way a surface faces, faking fine bumps.

Sources 80 Level: Making a tileable forest floor material

More like this Less like this

Game dev Trend

A mobile hit still setting records in month five

Clash of Critters passed an estimated $50 million in player spending less than five months after launch, and had its best day ever on October 9, while much of mobile gaming is shrinking.

$53.8Mplayer spend on iOS and Google Play since May 21

$678Krecord day, October 9

Monthly spend roughly doubled from about $7.7 million in month one to $14.6 million in month four, by AppMagic estimates. Web shop and ad revenue are not counted.

Why it mattersGrowth that keeps climbing months after launch points to live updates doing the work, not the launch. Store estimates are rough, but the direction is clear.

AppMagic
A market data company that estimates app downloads and revenue from store rankings.

Sources PocketGamer.biz: Clash of Critters surpasses $50m

More like this Less like this

Learn one thing

What does an orchestrator do in a team of AI agents?

An orchestrator is the part of a multi-agent system that takes a request, decides which specialist agent should handle it, passes along what that agent needs, and collects the result. It manages the work rather than doing it.

Think of it like thisLike a restaurant's expediter: they read each ticket, call it to the right station, check plates before they leave, and never cook anything themselves.

One agent with every rule for a large system tends to mix things up as its context fills. Splitting the work among specialists, each with its own instructions and a small context, keeps each one focused. Something then has to route requests and check results: that is the orchestrator.

Today's stories show two styles. Meta's orchestrator is plain code with one model call, so it behaves the same every time. Cloudflare's reviewer uses a model as its coordinator and had to tune which model and effort level that coordinator runs at. Either way, the orchestrator decides what each specialist sees, which is also where much of the cost goes.

The jobs an orchestrator does, after Meta's seven-step protocol. Specialists do the actual work.
multi-agent system
Several AI agents, each with its own instructions, working on parts of one task.
specialist
An agent set up for one kind of work, such as security review or schema changes.

Try this today

Software and AI 30 minutes For practitioners

Merge two agent skills that do the same job

Find skills that overlap, fold them into one file with one correct example, and stop half your rules from being silently dropped.

You needA coding agent that loads skills, such as Claude Code, with more than a handful installed.

  1. List your skills

    Look in the project's .claude/skills/ and your personal ~/.claude/skills/, plus any installed by plugins. Note what job each one claims in its description.

  2. Find same-job pairs

    Flag any two that cover the same task: commit messages, pull request descriptions, bug reports, changelogs. The study found an unrelated second skill did no harm; same-job pairs did.

  3. Merge into one rule list

    Write one SKILL.md with every rule you want to keep from both, resolving real conflicts yourself. Do not rely on a "this skill takes priority" line; it did not help in the study.

  4. Write one example that obeys every rule

    End the file with a single worked example and check it against each rule by hand. A wrong example spreads its mistakes.

  5. Remove the originals and compare

    Disable the two old skills, then run the same five prompts and count how many rules from each original show up in the output.

You know it worked whenRules from both original skills appear in the output, not just one skill's set. In the paper the merged file kept 96% to 99% of achievable rules, against about 61% for the clashing pair.

For youStart with the skills that write commits and PR descriptions across the plugin and SaaS repos; those are the likeliest to overlap with plugin-installed ones.

SKILL.md
The file in a skill's folder that holds its description, instructions and examples.

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

Hand a coding agent a repo that a previous agent wrongly called done, and it often calls it done too.

SWE-Residual: Evaluating Starting-State Robustness of Coding AgentsJinze Li, Weijie Liu, Jinfeng Xu et al. (HKU, UBC, University of Tokyo, Tencent and others)

Diagram of a failed earlier attempt, a clean start that succeeds and a residual start that fails, beside a bar chart where every model scores far lower from the residual start.
Image: Li et al., arXiv 2610.25899
The problem
Benchmarks start agents from a clean repo. In practice an agent often picks up half-finished or wrong work left by an earlier run that claimed success.
The idea
Build 198 starting states from 111 tasks by keeping the code that earlier agents submitted as complete but that fails hidden tests. Give a new agent only the original request and that state, with no hint that anything failed.
The result
Success fell 20.6 to 53.5 points against a clean start: on DeepSWE, GPT-6-Sol dropped from 65.6% to 33.5% and Gemini-3.8-Flash from 72.2% to 20.0%. In 58.9% to 88.2% of failed continuations the same tests failed at the end as at the start. Model rankings flipped between the two conditions.
Use it
When a fresh session picks up a branch, do not just say continue: give it the failing test output or tell it to re-run the tests first, or reset to a known good state.

For youMatters for long routines that resume each other's work: start every resumed run by re-running the checks.

More like this Less like this

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

ReadarXiv 2610.25899Code

Software and AI PreprintarXiv preprint

A small cheap model can watch a coding agent and stop runs that are going nowhere, cutting cost without losing solves.

StopLoss: Teaching Agents to Predict Failure and Stop EarlyJiarong Liang, Xueguang Ma, Dongfu Jiang et al. (University of Waterloo)

The problem
Failing agent runs burn tokens until they hit a limit. Using a large model as a judge to stop them costs a lot and, here, also stopped runs that would have succeeded.
The idea
Fine-tune a 7B to 8B model on finished runs labelled by whether they passed. At checkpoints it reads the last three actions and results and scores the chance of failure; a threshold tuned on successful runs decides when to stop. The agent itself is unchanged.
The result
Cost per solved task fell 24.2% to 30.6% on SWE-bench Pro (48.1% with a Qwen3-8B monitor), while keeping 99.0% of solves on SWE-bench Verified, against 89.5% to 91.8% for GPT judges. Monitoring 425 runs cost $0.44, against $4.18 to $33.20 for the judges.
Use it
The trained monitor needs your own labelled runs. The cheap first step is a hook that counts repeated failing tool calls and stops or escalates the run.

More like this Less like this

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

ReadarXiv 2610.25525Code

Also moving

This week on Toa Radar

Read the weekly summary: The week agents got fences and rulebooks
Tune mode is on in this browser. Turn it off