Diff

shiftindustry

Gemini 4 Argon ships restricted to cyber defenders

Google's newest frontier model isn't shipping broadly — Gemini 4 Argon is restricted to government users and vetted cybersecurity teams in its Fairwind Program, the first time a flagship release has been gated by capability risk rather than price or compute. It's a concrete sign that labs are starting to treat 'who gets access' as part of the safety stack, not just an afterthought, which matters for anyone watching whether frontier capability will keep diffusing freely or start fragmenting by vetting tier.

via google deepmind · hn front page · latent space

techniquetooling

Claude Code can now auto-build your evals

Anthropic shipped build_eval and hillclimb as Claude Code skills, turning eval-writing from a manual, often-skipped chore into a guided loop: baseline first, then one change at a time with an overfitting check before anything gets accepted. That's a meaningful shift — most teams shipping LLM features still skip straight to tweaking prompts without a real baseline, and this makes the harder discipline the path of least resistance instead. If you're the one deciding how your team verifies that an AI-written change actually helped, this is worth trying on real production traces rather than synthetic examples, since the tool pushes you to build the eval before you start optimizing.

Do it — 3 steps in your repos30 min

Enable the Claude Code auto-eval skills (build_eval and hillclimb)
Point build_eval at real production traces — conversation or request logs — rather than synthetic examples
Run the baseline eval before changing anything, then let hillclimb iterate one change at a time and check its overfitting warning before accepting a result

via hamel husain

lessonindustry

OpenAI disrupted a campaign stealing its model's reasoning

OpenAI says it disrupted a coordinated campaign that used adversarial querying to extract and distill its model's internal reasoning — not just its final answers — into a competing model. That's the first confirmation from a major lab that some of the open-weight ecosystem's rapid catch-up with frontier models may be adversarial extraction rather than organic research progress, which reframes the open-vs-closed model race as partly a security problem. It's a useful reminder that API terms alone don't protect what a model actually knows, worth keeping in mind for anyone deciding which model's API to build on.

What’s model distillation as an attack surface?

Distillation is normally a cooperative technique: a smaller 'student' model is trained to mimic a larger 'teacher' model's outputs, usually with the teacher's permission, to cut cost and latency while keeping most of its capability.

Most commercial API terms assume that without the teacher's actual weights, an outside party is only training on indirect text outputs — a weak, slow signal that takes enormous amounts of data to turn into something competitive.

OpenAI says this campaign ran large, coordinated query volumes specifically designed to reconstruct the model's internal reasoning chains rather than just its final answers — extracting far more of the teacher's 'knowledge' through the API than that assumption accounted for.

What's unresolved is how much of the broader open-weight progress wave is this kind of extraction versus genuine research gains, and what actually stops it — rate limits and terms of service clearly weren't enough on their own.

via openai

AI models just crossed a hacking capability threshold

Anthropic's own red-teamers found that both GLM-5.3 and Claude Mythos Preview can now fully hijack a program's control flow in a meaningful share of binary-exploitation trials — up from zero for the prior generation of each. That's not a benchmark inching upward; it's a threshold, the kind of jump that changes what 'a model could do this autonomously' means for security teams, not just researchers. It's a reminder that model capability now needs the same disclosure discipline as any other high-risk engineering change, not a footnote in a launch post.

What’s Control-flow hijacking (binary exploitation)?

A control-flow hijack is when an attacker gets a running program to execute code it was never meant to run — classically by overflowing a buffer, overwriting a return address or function pointer, and redirecting execution to attacker-chosen code. It's the mechanism behind most of the highest-severity 'remote code execution' vulnerabilities you see in CVE reports.

Historically this required a human exploit developer: find the memory-safety bug, understand the binary's layout, hand-craft a payload that survives the program's defenses (stack canaries, ASLR, etc.), and chain several small bugs into one working exploit. It's slow, skilled work — one reason offensive cyber capability has stayed a scarce, credentialed resource.

What changed here is that models are now completing that whole chain — find the bug, build the payload, redirect execution — end to end and autonomously, in a real fraction of trials, where the prior model generation managed none. The jump from 0% to single-digit percentages sounds small until you remember it's the difference between 'not yet possible' and 'possible, and about to get cheaper.'

The live debate is whether this cuts both ways: the same automation that lets an attacker chain an exploit also lets defenders find and patch the bug first. Which side benefits faster is exactly the kind of question frontier labs' red-team disclosures like this one are meant to inform — and exactly the kind of claim that's hard to verify from outside the lab.

OpenAI ships always-on proactive AI agents

OpenAI's new 'dots' assistants act continuously across a user's projects without being explicitly invoked — a real shift from prompt-and-response toward software that decides when to act on its own. It lands the same proactivity question the field has been circling all month, now shipped by the largest consumer AI company at meaningful scale. If you build on any model API, the interesting part isn't the capability itself — it's what 'always-on' costs in errors and trust once millions of people are using it unsupervised.

OpenAI pulled a model release over alignment failures

A frontier lab shipping a model and then pulling it back before wide release because it failed an internal alignment bar is a different kind of signal than a benchmark score — it's evidence that at least one lab's safety gate has real teeth, not just a line in a system card. Whether that becomes the norm or stays the exception is exactly the thing that gets buried in a press cycle unless someone is watching for it. It's also the sharpest test yet of this week's 'investigate the labs' argument: this is what falsifiable self-policing would actually look like, if it's real.

A generalist agent for controlling any computer

Holo4 is H Company's latest attempt at a 'generalist computer-use agent' — a model that operates a desktop or browser directly through screenshots and clicks rather than through an API built for it, a different bet than the agentic-coding wave has been making. It matters because the ceiling on what agents can automate has mostly been 'whatever exposes a clean API'; a model that's genuinely reliable at driving arbitrary UIs removes that ceiling for the large amount of software that will never expose one.

What’s computer-use agents?

Computer-use agents are models trained to operate a screen the way a person does: they look at a screenshot (or a live feed), decide where to click or what to type, and repeat — rather than calling a purpose-built API. The appeal is obvious: most software, especially internal and legacy tools, was never built with an API for an agent to call.

It's worked poorly for a long time because it stacks two hard problems at once: the model has to read a UI accurately (small buttons, ambiguous icons, popups) and it has to plan a multi-step task across many screens without losing track of what it already did — small misreads compound with every step.

What's changing is that a few labs are now treating this as its own model category rather than a side feature of a general model — training specifically on the click-and-observe loop instead of hoping a general-purpose model happens to be good at it. Holo4 is H Company's entry in that category.

The live debate is whether this converges with the coding-agent stack — since a lot of 'computer use' is really just automating internal tools that could, in principle, be given an API — or whether it stays a distinct category for the genuinely API-less long tail of enterprise software.