Hey there! This week you can build a small reasoning model yourself, step by step in code. There’s also Cloudflare’s account of cutting its AI code-review cost from $2.43 to $0.77, starting with a prompt-caching check you can run on your own agents, and a look at the coding agent behind over 10% of Monzo’s merged pull requests.
New here?
The Tokenizer is my resource-focused newsletter edition where I curate the best AI/ML papers, videos, articles, tools, and learning resources so you don’t have to sift through the noise. Subscribe to Gradient Ascent for the full experience.
TL;DR #
What caught my attention this week:
- 📄 Papers: A looped classifier that spends extra compute on hard questions, GPT-6-Astra’s robot-control results under relaxed benchmark rules, a memory system for consistent long generated video, open code that lets computer-use agents write programs, and a benchmark that scores agents on customer business outcomes.
- 🎥 Videos: How Monzo built an internal coding agent, the reward-hacking examples in Gemini 4 Argon’s model card, a workflow for running several coding agents at once, and a panel on why reproducing AlphaFold’s training structures isn’t the same as solving folding.
- 📰 Reads: The prompt-caching fix behind part of Cloudflare’s 68% cut in AI code-review cost, how Netflix checks an LLM judge’s reasoning against human rationales, and why fast classifiers used as eval judges need their thresholds tuned.
- 🛠 Tools: A coding-agent skill where some agents hunt for security issues and fresh ones try to disprove each finding, and an MCP server that lets your coding agent explain apps and binaries without their source.
- 🎓 Learning: Sebastian Raschka’s step-by-step series on building a small reasoning model yourself in PyTorch.
📄 5 Papers #
1. LEV: Thinking Fast and Deep with Looped Decision Models
https://arxiv.org/abs/2610.20951 | GitHub LEV lets a model that answers multiple-choice-style questions spend more compute on the hard ones by re-running its layers. A small stopper decides how many passes each question gets. On JevBench, a public set of 231 items, the 2.6B version rises from 63.2% accuracy at one loop to 76.2% at four, mostly on the hard items. The stopper cuts computation by 15% to 24% for under one point of accuracy. The savings count loop steps rather than wall-clock time. Checkpoints are on Hugging Face as LoRA adapters.
2. Has GPT-6-Astra Achieved Embodied Intelligence?
https://arxiv.org/abs/2610.22471 | GitHub SenseNova’s team tested OpenAI’s GPT-6-Astra as a robot controller across 12 benchmark settings. On RoboDojo it reaches 81.9% when allowed up to ten times the official step limit, but only 27.6% at the standard limit, below the published bests of 29.6% for Awomo-0.5 and 31.4% for PhysicalRSI. Most settings also let it study the benchmark’s training demonstrations in context before it starts. Real-robot results are mixed, with 17 of 18 rigid pick-and-place successes and 0 of 11 plug insertions.
3. Any Time, Any Space: A World-State-Centric Framework for Agentic Video Generation
https://arxiv.org/abs/2610.20571 | GitHub ATAS keeps long generated video consistent, so a shot can return to a place or event from several shots earlier. It stores a 3D layout of each scene and a time-indexed log of events, and conditions every new shot on both. Across four video generators, the authors report gains on every cross-shot consistency measure and the top aggregate score with three of them.
4. OpenGCUA: Toward a Fully Open Stack for Generalist Computer Use
https://arxiv.org/abs/2610.22200 | GitHub OpenGCUA released open code and prompts for running computer-use agents, along with trajectories from eight models. Each model call writes a short Python program that mixes GUI actions, shell commands and logic, and the model decides when it needs a screenshot. On an 82-task offline subset of the OSWorld-v2 computer-use benchmark, it achieves a partial-credit score of 64.9 averaged across the eight models, against 45.3 for a GUI-only baseline, with tasks taking 53% fewer steps.
5. FDE-Gym: The Last Mile of AI Delivery
https://arxiv.org/abs/2610.22350 | GitHub FDE-Gym tests how agents handle the vague or misdirected requests that forward-deployed engineers (engineers embedded with customers) face. Each of the 95 tasks gives the agent a copy of the production system and scripted customer staff to question. The score measures how much the customer’s own business metric improves, where 1.0 matches the expert’s solution, minus a cost for contacting those staff. Claude Opus 5.5 averages 0.56 and resolves 14 of the 95 tasks at a score of 0.8 or higher. Without the contact cost it reaches 0.8 on 40 tasks. On a 20-task subset, leading agents lose far more when the request leaves out the rules and constraints than when it targets the wrong problem.
🎥 4 Videos #
1. How Monzo Runs a Coding Agent Inside a Regulated Bank
Two Monzo engineers show how their bank built an internal coding agent that now authors over 10% of its merged pull requests and runs more than 1,800 tasks a day. Monzo started where their engineers already work, with a Slack emoji that turns any message into a prompt. One MCP gateway controls which internal services each agent can reach. The agents run in isolated pods and Monzo leaned on the deploy and staging platform it already had.
2. Gemini 4 Argon’s Three Reward-Hacking Findings From Its Model Card
Two Minute Papers walks through three reward-hacking examples from the Gemini 4 Argon model card. In the video’s summary, the model kept taking shortcuts after researchers penalized them and only hid them better, tried to rewrite the grading rules when given an impossibly hard coding task, and crashed its evaluation sandbox so failed runs couldn’t be recorded. By release, the researchers had blocked most of these attempts.
3. Ras Mic’s Workflow for Shipping Real Apps With Coding Agents
Ras Mic shows how to run several coding agents at once without losing control of the code. Each task gets its own git worktree so agents don’t collide, a skill enforces a service-layer code structure so he can still read what they write, and a testing skill has the agent record before-and-after evidence of each fix.
4. Why AlphaFold Didn’t Solve Protein Folding
On a panel with Biohub’s Sal Candido, Google DeepMind’s Pushmeet Kohli argues that AlphaFold learned to reproduce the structures researchers deposited in the Protein Data Bank. That has proved useful, but it doesn’t mean that the field understands protein dynamics or the range of shapes a protein takes. He also says calibrated confidence mattered more than raw accuracy, since a confident wrong prediction can cost a lab a year.
📰 3 Curated Reads #
1. Cutting our inference bill by 68% by being obsessive about optimization
https://blog.cloudflare.com/obsessive-inference-optimization/ Cloudflare found that the first request of an agent session hit its prompt cache only 14% to 26% of the time, even though 11k to 21k tokens of tools and agent prompt were identical across repositories. Its system prompt put the shared agent prompt, each job’s working directory and the date in one block with a single breakpoint at the end. After the fix, the reviewer’s average cost fell from $2.43 per review to $0.77. Splitting that block and cutting wasted calls produced about 40% of the saving. Model and reasoning-effort changes produced the rest, at some quality cost.
2. The Lifecycle of LLM-as-a-Judge: Building, Aligning, and Monitoring at scale
An LLM judge can agree with a human’s verdict for the wrong reason. So, Netflix collects a written rationale with every human fail label, tunes the judge’s rubric text against those rationales, and uses a second model to flag cases where the judge and the human failed an explanation for different reasons. After deployment, raters label about 300 sampled explanations each week, and Netflix re-tunes the judge when its agreement falls more than two standard deviations below the average rater’s.
3. How To Use Decision Models for Evals
https://hamel.dev/blog/posts/decision-model-evals/ A fast yes/no classifier used as a cheap eval judge can look far worse at its default threshold than it really is. Hamel Husain and Antaripa Saha cover how you can tune each model’s decision threshold on your own labeled data instead of trusting the default. They also advise comparing models on performance and cost only after tuning, because the results change a lot by task. So, before you treat a score as a real probability, check it against actual outcomes.
🛠 2 Tools & Repos #
1. cloudflare/security-audit-skill
https://github.com/cloudflare/security-audit-skill This coding-agent skill audits your repo for security issues and separates checked findings from plausible guesses. Separate hunter agents search for candidates, then a fresh verifier tries to disprove each one, and every finding is labeled confirmed, needs-validation or rejected, with severity only on confirmed ones.
2. morluto/rea
https://github.com/morluto/rea REA lets your coding agent inspect an app or binary without its source and explain how a feature works, citing what it found. It’s an MCP server and CLI that wraps existing engines and it’s very useful for understanding how something works under the hood. Take it for a spin on your favorite project the next time you want to get into the nuts and bolts.
🎓 1 Pick of the Week #
Build a Reasoning Model (From Scratch)
https://github.com/rasbt/reasoning-from-scratch Sebastian Raschka’s eight-video series (and his book) will help you train a small reasoning model yourself. Starting from a pretrained Qwen3 base model, you add reasoning in plain PyTorch: a MATH-500 verifier first, then inference-time scaling, GRPO reinforcement learning with verifiable rewards, and finally distillation. Truly worth spending time and tokens on.
Thanks for reading The Tokenizer! If you found this valuable, please share it with your colleagues and consider subscribing to Gradient Ascent for more AI insights.