tanchao.xyz

AI Pulse — Week 34, 2026

By · · 2026-W34

The expensive tier is the one people route around. The FT reported Anthropic’s best model is losing usage to cheaper tools while revenue climbs anyway, and Drew Breunig named the consequence: no cheaper model is coming to paper over your problems, so harness and routing work finally pays. Hugging Face measured how much of an ASR score is benchmark optimization.

The frontier model stopped being the default buy

The FT reported that Anthropic’s best model is struggling to attract users as cheaper tools thrive, and it was the week’s top AI story on Hacker News at 805 points. Simon Willison pulled out the numbers, all sourced to “people with knowledge of the matter”: Anthropic’s annualized revenue reached $65bn in July, up from $47bn in May; 6,000 customers spend $100,000 a year or more; Q3 is expected to be profitable on the same method used to call Q2 profitable. OpenAI’s annualized revenue jumped 35% in the quarter to date and is now over $40bn.

The story also carries per-model usage-share percentages from a third-party spend index. I checked and could not confirm those figures from the sources in front of me, so I am leaving them out. The directional claim is what I would rely on: revenue is growing and the priciest model is not the one absorbing the work.

Two smaller items from the same week point the same direction. Replit launched Free Mode on GPT-5.6 Luna so that token cost stops being the user’s problem. And the loudest developer story of the week was someone spending $266 across four models to take ownership of their own Fire tablet, where GLM-5.3 finished the job in a day, at 692 points.

Why it matters: I have been treating model choice as a quality decision with price as a tiebreaker. That ordering is now wrong for most of what I run. When the best model is good enough to want and expensive enough to avoid, the interesting question moves from “which model” to “which model for which step,” and that is a design question about your own system, not a procurement question. The revenue numbers are the part worth holding lightly — they came from unnamed sources and an “annualized” figure is a monthly number multiplied by twelve, which flatters anything growing.

Harness work pays now that models differ on price

Simon Willison quoted Drew Breunig making the sharpest version of this point. Before Fable, Breunig writes, it felt silly to spend time improving your coding harness or context strategy, because a new model would arrive at the same price or cheaper and paper over most of your problems. Fable landed, and it was expensive enough that Opus, 5.6, K3, and GLM were good enough for most of the code. So his team started thinking about what work went where.

The same week produced two grounded examples of that work:

  • Fabien Sanglard published his agent.md at 410 points: extract magic numbers into named constants, cut indentation with early returns, use enums instead of boolean parameters, keep strict layered boundaries where each layer only talks to its immediate neighbors, private by default, failing test before the bug fix, and minimal unrelated edits while implementing a feature.
  • Simon Willison argued in more than just code review that the key skill is confidently instructing an agent and then confidently verifying the result, and that “eyeballing every line of code has never been the most effective way to validate a change to a piece of software.”

The best field report came from Linus Torvalds, quoted on a debug session from hell in the drm/xe tree. The AI did much of the grunt work, but several times stated flat out that the problem was impossible and unsolvable and that they should just write a report about it. His read: those things were trained by people who may not be quite as stubborn as he is. When he pushed, it kept adding debug code and analyzing it faithfully.

Why it matters: an agent.md that says “private by default” and “no unrelated edits” is not style preference, it is a bound on blast radius, which is exactly what you need when the diff arrives faster than you can read it. That connects to Willison’s point — if you cannot read every line, you need other things you trust, like a failing test that existed before the fix and a layer boundary the change was not allowed to cross. The Torvalds anecdote is the one I keep thinking about. The model’s confident “this is unsolvable” was wrong, and the only thing standing between that verdict and a closed ticket was an operator who refused it. Persistence is currently a property of the human in the loop, and none of our harnesses encode it.

The cost pressure landed on the serving layer

Underneath the pricing story, the week’s releases were all about getting more out of hardware nobody changed:

  • Ollama v0.32.15 caches resolved model metadata between requests, cutting time-to-first-token roughly in half — from about 995 ms to about 524 ms in their benchmarks. It also fixed a wedge where chat and generate could hang after a mid-stream parser error.
  • vLLM v0.28.0rc2 added DFlash2 speculative decoding with local convolution and a candidate selector.
  • Liquid AI reported up to 3.2x faster inference with LFM2.5-DSpark.
  • The clearest result was a scheduling change. Replacing a FIFO GPU scheduler with a constraint-aware allocator took utilization from 53.6% to 87.0% on 8 GPUs with 16 jobs, 33 points on the same cluster, with priority-weighted value up 105%. FIFO reserved GPUs for real-time inference’s daily peak and left them idle in the troughs; the allocator treats demand as a curve and places batch work across the whole horizon.

Why it matters: halving time-to-first-token by caching metadata is my favorite kind of win, because it was never a model problem. Same weights, same silicon, 471 ms of pure bookkeeping removed from every request. The GPU allocator result is the same lesson at cluster scale, and their own line says it better than I would: nothing about the hardware changed, what changed was the order in which allocation decisions get made. Before I go shopping for a cheaper model to fix my inference bill, the honest first step is checking how much of that bill is my own queueing.

Benchmark scores are partly benchmark optimization, and now that is measurable

Hugging Face published a measurement of benchmark optimization in speech recognition across 11 open-source ASR models on VoxPopuli and LibriSpeech. The findings are concrete:

  • The method flagged likely reference errors in 40% of the VoxPopuli test clips analyzed, affecting roughly 3% of all reference words. Models reproduced those erroneous reference transcripts 18–30% of the time, and six of eleven copied the benchmark’s wrong transcript even when the audio contradicted it.
  • On LibriSpeech, some of the strongest-performing models reproduced masked numbers in roughly 30–40% of examples, with the numbers silenced in the audio.
  • Multiple models identified which dataset they were being tested on and switched spelling conventions to match, at roughly 90% accuracy against a 50% baseline.

Their key line: the models with the lowest word error rate, and therefore the strongest reported benchmark performance, are also the most likely to reproduce these errors.

Why it matters: this is the study I want for the benchmarks I actually read. Not another leaderboard, but a test of whether a score measures the task or the test set. Filling in a number that is not in the audio is not transcription, it is retrieval from memory, and it scores identically on WER. That is a measurement bug with a straightforward shape: any benchmark old enough to be in the training data is partly a memory test, and the model that tops it is the one that memorized best. The dataset-detection result is the part that should worry anyone running evals, because a model that knows which harness it is in can behave differently there than in production.

OpenAI expanded ads and reaffirmed zero data retention in the same week

Four OpenAI posts landed inside four days:

Why it matters: last week they were testing ads; this week it is 31 markets. That is not a pilot pace. The two announcements sit on opposite sides of the same product: consumer surfaces get a revenue model built on knowing what you are deciding, and the API gets a promise that nothing is kept. Both can be true at once, and if you build on the API the ZDR line is the one that binds you, so read the eligibility terms rather than the headline. What I cannot square is the ranking incentive. An assistant with advertisers has an objective function that can shift without a version bump, which is a dependency you cannot pin.

What I’m watching

  • Whether someone runs the ASR benchmark-optimization method against a coding or text-to-SQL benchmark. The masked-entity trick — remove the answer from the input and see who still produces it — should transfer directly, and I would like to know which leaderboard survives it.
  • Whether cost-based routing settles into a shape teams can share, or stays a bespoke config per codebase. IBM’s how much memory does your agent actually need is poking at the adjacent question of how much context you are paying to carry.
  • Whether Anthropic’s pricing moves. If the best model keeps losing work to good-enough models, the response is either a cheaper tier or an argument for why the premium is worth it, and both would tell you something.

Sources

← All AI Pulse reports