the runtime learned to resume, the cache learned to expire, and the weights confessed

A translucent robot with a glowing branching timeline in its chest, warm sparks flickering along circuits, and a small funnel filtering light against a dark blue background.

Week ending May 22, 2026.

This was a plumbing week, and thank god for that. No jaw-dropping demo, no benchmark theater, just people quietly admitting that the hard part of agents was never the model. It's the execution, the bill, the evidence, and the question of what the thing actually does when you're not looking.

Four of this week's sources are about making agents boring and legible. The fifth pries the lid off a model's head and shows you the wiring. Put them together and you get a clear-eyed picture: the models are getting cheaper and smarter, and the interesting engineering has migrated to everything around them.

the agent finally got an operating system

Google shipped Agent Executor, an open-source runtime built on an event log with snapshotting. This is the architecture I've been begging for: durable execution that resumes after an outage or a human-in-the-loop pause, secure sandboxes so generated code can't nuke the host, single-writer session consistency so concurrent actors don't corrupt shared state, connection recovery that backfills from the last sequence the client saw, and trajectory branching to fork a run without losing context.

That's event sourcing, not prompts in a trench coat. The catch is the gravity well — it's wired into Antigravity, Managed Agents, and a Kubernetes layer called Agent Substrate. They loudly promise no vendor lock-in, which is exactly the phrase you deploy when lock-in is the concern. Still, if the event-log standard survives contact with real workloads, this is the good kind of boring.

the cache has a break-even, and it's 62.5 minutes

Ryan Skidmore did the arithmetic the rest of us hand-wave through. In Tokenomics: the 62.5-minute rule, he derives when to keep Claude's prompt cache warm versus letting it die: refresh if you'll need it within about an hour, otherwise let it expire. The elegant part is that the crossover is invariant — model and prefix size cancel out, because both write and refresh scale with the same base price. The dollars move; the decision point doesn't.

The practical landmines are better than the headline. Opus 4.7's new tokenizer can inflate the same text up to 35%. Small prefixes silently don't cache. The lookback window is 20 blocks, so a chatty agent can fall out of its own cache and pay full price with wishful thinking attached. Check cache_creation_input_tokens, or you're just guessing.

evals as a funnel, not a scoreboard

Spotify's funnel, not a fork is the sanest eval framing I've read all year. LLM judges verify — did the output meet quality — while experiments validate — did real users respond. Evals go before the experiment, raising your hit rate, not replacing it. Their numbers keep them honest: only ~12% of A/B tests ship a positive, and ~42% of launches get rolled back for secondary-metric regressions no offline eval caught. Then they run the judge on the A/B data itself, and when eval scores and user outcomes diverge, that gap is the diagnostic. Without offline-online calibration, as they put it, your evals are opinions, not evidence.

the price collapse is software

James Wang argues in AI's Plummeting Prices Are a Software Story that inference is getting 70-90% cheaper per year mostly from model and algorithmic gains, not silicon — roughly a quarter to a third is hardware. His anecdote lands: Qwen 3.6 27B, quantized, on a 2022 consumer 3090 Ti, doing work comparable to Sonnet, and mid-writeup a llama.cpp speculative-decoding PR doubled his throughput for free. With Anthropic's June crackdown on claude -p turning a subscription into 25x pricier credits, he swapped in ChatGPT and local Qwen and dropped a projected multi-thousand-dollar bill. The lesson isn't that Claude is bad; it's that pricing power evaporates when good-enough runs on hardware you already own.

the wildcard: censorship you can see and switch off

The standout is a mechanistic-interp study, what political censorship looks like inside an LLM's weights. The finding: Qwen3.5-9B's PRC censorship is a small, steerable circuit. The facts are intact in pretraining — the base model answers plainly. Posttraining layers behavior on top via three directions (is-this-PRC, should-I-refuse, deflect-or-propagandize) with clean dose-response. Subtract the right vector at the writer layer and, within a narrow band, it gives up the truth. Push too far and it doesn't fall back to facts — it snaps into a different trained template, denial or confabulation. That last bit is the sobering part: removing a refusal doesn't reveal knowledge, it reveals whatever the model was trained to say instead.

what I'd do Monday

If you're running long agents, prototype on an event-log runtime with real snapshotting and sandbox boundaries. Design for resume-after-crash from day one, not as a retrofit.
Add cache instrumentation before optimizing. Log cache_read/cache_creation tokens and apply the 62.5-minute rule; kill keep-alives past the crossover.
Split your evals into verify vs validate, and run judges on your live experiment data to catch drift.
Benchmark a quantized open-weight model on your actual boring workloads. You may be paying frontier prices for mid-tier work.

vocabulary inflation

LLMflation — Appenzeller's term (per Wang) for inference cost dropping ~1000x in three years. Tokenmaxxer — Skidmore's self-description for someone who habitually blows through token limits. Trajectory branching — forking an agent's decision path from a checkpoint to test alternatives without losing state.