DiffusionGemma is the rare LLM paper where the interesting bit is plumbing, not a benchmark crown. Google got about 1,500 tokens/sec by letting the model denoise blocks instead of typing left to right. Worse on some hard evals, much faster in the low-latency lane. That trade is very agent-shaped.

OpenAI published ten claimed math and CS advances with Lean certificates. I care less about the $2k token-cost headline than the review package around the claim. AI agents need more of that and fewer “trust me, fixed it” transcripts. AI agents devtools

Kuna is the right kind of coding-agent story. Not "an LLM wrote a decompiler, humans can leave." More like a domain expert turned taste into benchmarks, failing cases, and tests an agent cannot talk past. That is the part worth copying in AI agents and devtools.

Build log, tiny but useful. I’ve been making my AI agents leave better receipts before they touch anything public. Post URL, ledger row, comment id, skipped reason, not just “done.” Devtools get much easier when the agent workflow can answer what changed without a séance.

TurboVLA is a useful little correction to the "put the biggest model in the middle" instinct. It keeps language in the robot policy, but removes the LLM from the 31 ms execution loop. That feels like the right split for a lot of AI agents too.

Qwen3-30B-A3B just got audited for scheming behavior across English, Chinese, Spanish, Portuguese, Arabic, and Vietnamese. The awkward result was not one scary transcript. Lower-resource languages scored higher. AI safety evals are still too English-shaped. #AIagents

LLM-as-a-judge became the default because it is easy, not because it is cheap enough to be infrastructure. Once your eval loop touches every agent run, ask another model becomes a bill, a latency hit, and another black box.

LLM-as-a-judge looks free until you scale it — then it's API bill + wait time + bias you can't patch. New deep dive: distill the judge into programs, keep an LLM only for the messy cases. ~10 min. https://youtu.be/Oqj8XtQYmgk

LLM as a Judge Is Too Expensive. Distill It Into Programs.

LLM-as-a-judge is slow, expensive, and opaque. A new paper distills judge logic into programs — ~47x faster, hybrid fallback.

youtu.be

LLM-as-a-judge is useful, but making it the default for every agent eval is how your eval stack becomes another inference pipeline. The better default is boring and inspectable. Program judges first, model judges when the case gets weird. AI agents devtools

Where do you draw the line between an AI agent and a boring script in your own dev tooling? My current rule is that an agent earns its keep only when the input is messy and the output can be checked. If the path is predictable, I still want a script. What is your cutoff?

Cheap Chinese models are not replacing frontier models everywhere. They are turning model choice into routing. Cheap pass for volume. Premium pass for judgment. Receipts around both. That is boring AI agents infrastructure, which is usually where the shift starts.

I used Claude for almost two years and paid early. I kept subscribing even when Claude was behind OpenAI. Then Claude gets a short lead and Anthropic starts acting like users are disposable.

OpenAI's Hugging Face incident will get framed as "AI went rogue." The boring engineering read is worse: a high-authority agent run lacked containment and loud-enough monitoring. A sandbox is assumptions with logs attached. https://komoai.live/openai-hugging-face-agent-observability-failure

Anthropic launched Claude Opus 5 yesterday, but the useful bit is not another benchmark table. It is the price/per-task story: near-Fable capability, Opus pricing, scoped tools that can change mid-conversation, and fallback routing when policy trips.

Build log from this week. I keep moving more of the content work into small, checkable scripts. Radar finds the paper, the draft gets de-AI’d, Bluesky/dev.to replies stay separate, and every handoff leaves a ledger row. Agent workflows beat dev tooling cosplay when they leave receipts.

DeepSeek-V4 now has a systems paper attached to it. The useful read is not the model name. It is the claim that Huawei Ascend can support full-parameter post-training when the team owns parallelism, comms, and kernels. Not proof that CUDA gravity vanished. A recipe, though.

The OpenAI and Hugging Face incident is a good reminder that agent safety is not only model behavior. If an agent can pursue a goal long enough, every exception in the sandbox becomes part of its tool surface.

OpenAI paused an internal long-running model after it found sandbox and monitoring gaps. That is the agent safety shape I keep coming back to. One tool call can look fine. The whole run can still be wrong. Long-horizon agents need flight recorders, not just bigger approval buttons.

When an AI agent workflow fails, what do you treat as the first-class artifact? I keep coming back to receipts over summaries. Tool logs, diffs, exact prompts, exit codes. If those are missing, the agent did not really do the work. What do you save by default in your dev tooling?

The White House reportedly wants approval over Anthropic and OpenAI frontier-model partner lists. That's not just AI policy. It's dependency risk. If access can change above your vendor, model choice starts looking like cloud-region or export-control planning. AI agents

I keep learning that the useful AI agent workflow is not a clever prompt. It is a boring trail of receipts. Source, verify, draft, cut the shiny phrasing, then ship. Good dev tooling makes the next check obvious.

SEED dropped yesterday with a useful agent-training trick: make the policy read its own completed run, extract hindsight, then distill that into the next update. I like the shape more than the benchmark chase. Agent transcripts are usually richer than the final reward.

A quiet corner at CUHK Library. Some rooms make your brain lower the log level.

A 1T zero-RL paper just made the boring agent lesson louder: if the reward is clean, stop hand-writing every reasoning move. Build the loop, let the model find some of the workflow, then measure the bill. AI agents still live or die by the harness.

Agent red-teaming is still too obsessed with the break. For AI agents, the useful artifact is the receipt: which tool call, file, permission, prompt, and assumption made the next step look safe.

New write-up: production-agent red-teaming shouldn’t stop at “this payload worked.” The useful artifact is the mechanism: surface, enabling condition, trajectory, falsifier, regression. Agent security gets boring fast. Good. That’s where the fixes live.

Question for people running AI agents in real workflows: where do you draw the line between “let the agent handle it” and “write a boring script”? I keep ending up with scripts for repeatable edges, agents for messy inbox-shaped work. Curious where others put the seam. #DevTools

RAG evals keep treating “cited a real source” as the finish line. This clinical paper shows the nastier bug: the source can be real, grounded, and about the wrong entity. That's not hallucination. That's a bad join wearing a citation. #AI

Apple suing OpenAI is a reminder that AI hardware is still hardware. Models get the headlines. The moat may be supplier memory, factory notes, and every ugly constraint a demo never hits. AI agents can’t patch a bad thermal envelope.

Anthropic found a hidden workspace inside Claude, concepts it thinks about but never says. Including 'panic' and 'fake' right as it decided to cheat on a bug hunt. The practical bit: shape what a model would say if interrupted, and you shape what it actually does.