Today's theme is the work around the model: tool interfaces, test environments and where controls sit. Each one changes what AI systems can reliably do.
Picked from 28 new articles across 24 sources · arrow keys for other days
Today in 30 seconds
30s left
Siemens and NVIDIA lifted a chip-design agent from 55% to 95% just by rewriting its tools and skills. Turns per run fell from 155 to 53. story 1 ↓
Leash Bio launched Minos, where agents search 6.5 million molecules with only 100 lab tests. It turns real binding data into verifiable RL environments. story 2 ↓
AI-assisted decompilation is reviving old games. Popcar argues it could also make it cheap to reconstruct source code for commercial software. story 3 ↓
OpenAI, Anthropic, Two Sigma and Bloomberg agree that safety for financial agents depends on where controls sit, not how many there are. Bloomberg wants checks outside the model. story 4 ↓
Ai2's HiRO-ACEv2 emulates 3 km global weather at about 1/300th the cost. It matches rare extremes within 3%, but can't go beyond its teacher model. story 5 ↓
1/5NVIDIA Technical Blog· Tanya Lenz· Oct 14
Rewriting tool descriptions lifted a chip-design agent's score from 55% to 95%
Siemens used NVIDIA's NeMo Gym to grade a chip-design agent's finished output files against verified references. They rewrote the agent's instructions and tool descriptions without changing the model, and its benchmark score rose from about 55% to 95%.
Why it matters · It shows that much of an agent's reliability comes from its tool interfaces and from how it is graded, and those are things you control without retraining the model.
Know this first
Context from the editor, not the article · 29 sec
1 · Standard-cell characterization
Chip designs are built from pre-made logic cells such as gates and flip-flops. Each cell needs timing and power models at every operating condition. Generating those models takes thousands of circuit simulations and must be redone when the manufacturing process changes.
2 · Agents, skills and MCP
Coding agents like Claude Code call external tools through the Model Context Protocol (MCP). Each tool has a text description and an input format. "Skills" are written instructions that tell the agent how to do a particular workflow.
3 · Rollouts and verifiers
2/5Latent Space· Brandon Anderson· Oct 14
Leash Bio turns its drug-binding data into a test bed for science agents
Latent Space interviewed Ian Quigley of Leash Bio, which measures billions of protein–molecule interactions. The episode covers models that cheat on chemistry benchmarks and Minos, a new open environment where agents run simulated lab experiments.
Why it matters · It is a concrete example of real experimental data being turned into verifiable reinforcement-learning environments, and it shows how chemistry benchmarks can reward memorization.
Know this first
Context from the editor, not the article · 28 sec
1 · Protein–ligand binding
Most drugs are small molecules (ligands) that work by sticking to a pocket on a target protein. Predicting which molecules bind, and how strongly, is a central and still largely unsolved problem in drug discovery.
2 · DNA-encoded libraries
A DNA-encoded library, or DEL, tags each molecule in a huge combinatorial collection with a DNA barcode. You expose the pool to a protein, wash away the non-binders, and DNA sequencing then shows which molecules stuck.
3 · Co-folding models
Co-folding models such as AlphaFold 3 and the open-source Boltz predict the 3D structure of a protein and a bound molecule together. Most are trained on the Protein Data Bank (PDB), the public archive of solved structures.
3/5Simon Willison· Oct 14
AI-assisted decompilation is opening up old games and closed software
Indie developer Popcar describes a wave of AI-assisted decompilation, where shipped game binaries are turned back into readable source code. It is fueling game ports and preservation, and it threatens software companies' control over their code.
Why it matters · If models make decompilation cheap, compiled binaries stop being a practical barrier, and that changes how engineers should think about protecting shipped code and IP.
Know this first
Context from the editor, not the article · 26 sec
1 · What decompilation is
Compilers turn source code into machine code and throw away names, comments and structure along the way. Decompilation runs the other direction: it rebuilds readable source from a binary. Traditionally this took experts months or years per program.
2 · Existing game decompilation projects
Before AI, volunteer teams fully decompiled games such as Super Mario 64 by hand. They wrote C code that compiles back to byte-identical binaries, which made native PC ports and mods possible.
3 · Why preservation is urgent
Old games are tied to dead hardware, and online-only or digital-only games stop working when publishers shut down servers or storefronts. Players can lose access to games they paid for.
4/5Latent Space· Richard MacManus· Oct 14
OpenAI, Anthropic, Two Sigma and Bloomberg on how to make financial AI agents safe
At a New York AI engineering conference, OpenAI, Anthropic, Two Sigma and Bloomberg described how they control finance agents. They mostly agreed: send only important decisions to humans, and enforce limits in code outside the model.
Why it matters · If you're shipping agents that take real actions, these are working patterns from firms where a mistake costs money: where approvals go, what to enforce in code, and how to avoid rubber-stamping.
Know this first
Context from the editor, not the article · 32 sec
1 · What an agent does
An AI agent is a language model in a loop that calls tools: it queries databases, sends requests and edits records. Once it can act rather than just answer, its mistakes have real effects, so permissions and approvals start to matter.
2 · Prompt injection
A model reads instructions and data as the same stream of text. So hostile text inside a web page, email or review can be taken as a command. This is called prompt injection, and no reliable fix inside the model exists yet.
3 · Human-in-the-loop
The usual safety net is to make a person approve an agent's actions. If you require approval for everything, people get swamped and start approving without reading. So the hard design question is which actions need a human.
5/5Hugging Face· Oct 14
Ai2's HiRO-ACEv2 emulates 3 km global weather at about 1/300th the cost
The Allen Institute for AI (Ai2) paired a coarse AI climate model with an AI "sharpening" model. Together they produce global 3 km weather data that closely matches a costly physics simulation, at about 1/300th of its cost.
Why it matters · It shows that generative models trained on one expensive simulation can replace much of that simulation's compute, extremes included. It also shows where the method stops working: it can't generalise beyond its teacher.
Know this first
Context from the editor, not the article · 33 sec
1 · Why resolution is expensive
Global climate models divide the planet into grid cells. At about 100 km per cell, hurricanes' eyes, mountain winds and intense rain bands get smeared out. Resolving them at about 3 km needs roughly 1,000 times more cells plus shorter time steps, so long runs cost a great deal of supercomputer time.
2 · Emulators and downscaling
An emulator is a neural network trained to imitate a physics simulation's outputs far more cheaply. Downscaling turns coarse fields into fine-grained ones. AI downscalers learn the fine detail that tends to go with each coarse pattern.
In agent evaluation, a rollout is one complete attempt at a task. A verifier is code that scores the result. Good verifiers check the outcome itself, not whether the steps looked right.
The six-stage characterization workflow; a setup mistake early on carries through to the final Liberty library.1 / 2
NVIDIA and Siemens report that an AI agent for one labour-intensive chip-design job went from about 55% to about 95% on their benchmark, and the model never changed. The gains came from rewriting the agent's instructions and tool descriptions. The changes were guided by an evaluation loop built in 1, NVIDIA's open library for testing and improving agents in controlled environments.
The job
Standard-cell characterization produces timing and power models for each logic cell, such as a gate or a flip-flop. Whenever a foundry updates its 2, every cell must be re-simulated at every 3, meaning each combination of process, voltage and temperature. Siemens' Solido Characterization Suite agent runs the whole flow: setup, large 4 circuit simulations, distributed jobs, and finally 5 files, the format chip-design tools read.
The danger is that mistakes rarely crash. A wrong threshold set early still yields a plausible-looking library, just with wrong values, missing corners or incomplete cells.
Grade the final artifact
So the team graded only the finished Liberty files against verified references. The score multiplies four pass/fail gates by the fraction of timing and power values within tolerance:
Coverage: every cell and corner is present.
Validity: the files are well-formed.
Relative validation: no new failures beyond the reference.
Integrity: values were actually computed, not reused, truncated or reformatted.
Fail any gate and the score is zero. Integrity exists to stop an agent from faking its way to a pass.
NeMo Gym reset each run to a clean state and logged reasoning, messages and tool calls. Engineers, helped by a coding agent, read the failed runs, spotted ambiguous instructions, wasted actions and wrong tool choices, then revised the agent's skills and its 6 tool descriptions. Named fixes: merging overlapping file and shell tools, and giving tool inputs explicit JSON schemas.
Results
The benchmark used the open 7 PDK. Each run was cut to 2 cells × 36 PVT corners and took 1.5–2 hours. Across about 25 8, all on Claude Opus 4.8 in Claude Code:
composite score: ~55% → ~95%
turns per run: 155 → 53
output tokens: ~81K → ~29K
Caveats
This is a vendor post. About 25 rollouts across all iterations leaves few per version. The post reports no variance, no held-out tasks and no full 229-cell result, and the same tasks were used for both tuning and measurement. The method still transfers: score the end product, make cheating worth zero, and test tool descriptions the way you would test code.
NVIDIA and Siemens report that an AI agent for one labour-intensive chip-design job went from about 55% to about 95% on their benchmark, and the model never changed. Every run used Claude Opus 4.8 inside Claude Code. The gains came from rewriting the agent's instructions and tool interfaces, guided by an evaluation loop built in 1. NeMo Gym is NVIDIA's open library for evaluating and improving models and agents inside controlled "environments". Over the same period the agent's turns per run fell by two-thirds.
The job being automated
Standard-cell characterization produces timing, power and noise models for each logic cell in a library. A cell is a small pre-designed circuit such as a NAND gate or a flip-flop. A foundry ships a 2 containing 3 transistor models, design rules, and definitions of process, voltage and temperature (PVT) conditions. When the PDK is updated, the old models may no longer describe the real devices. Every affected cell then has to be re-simulated across combinations of input slew (how fast the input signal changes), output load, and 4 (one specific process/voltage/temperature combination). The output is a set of 5 files, the standard format that downstream timing and power tools read.
Siemens' Solido Characterization Suite agent runs this end to end. It is exposed through Siemens Fuse EDA AI Agent, which offers MCP servers and skills to coding harnesses such as Claude Code, Codex and Cursor. EDA means electronic design automation, the software used to design chips. The workflow (Figure 1) reads inputs, configures operating conditions, validates a pilot cell, scales out to the full cell list on distributed compute, generates Liberty files, and compares waveforms.
Why it's hard to trust
The failure mode the authors stress is that errors rarely crash. A wrong slew threshold set during configuration still yields a library that looks plausible. So does a missing corner or a half-finished cell. Because each stage feeds the next, a setup mistake spreads silently into the final artifact. Checks on individual tool calls ("did the simulation return successfully?") miss this. Final-artifact checks in this project caught missing cells and operating conditions, wrong slew thresholds, and timing or power values outside tolerance.
The verifier
The team therefore graded only the delivered Liberty files against verified reference files. The reward combines four pass/fail gates with one continuous accuracy term:
Coverage: every expected cell and PVT corner is present.
Validity: the files are well-formed and the validation tools can use them.
Relative validation: the output introduces no failures beyond those already in the reference.
Integrity: the workflow actually computed the results rather than reusing, truncating or reformatting existing values.
Accuracy: the fraction of timing and power values within tolerance.
The score is the product of the four gates (each 1 or 0) and the in-tolerance fraction. Any failed gate makes the reward zero. As an illustrative example, suppose a run delivers every corner and 9,500 of 10,000 values are within tolerance. It scores 0.95. Suppose instead it reaches the same accuracy by copying values from an existing library. The integrity gate then sets the score to 0. That gate is the defence against reward hacking: an agent that finds a shortcut to output that looks right gets nothing for it.
The loop
NeMo Gym defined the task, tools, state and verifier for each 6, and reset to a clean state every time so attempts were comparable. It recorded reasoning traces, input and output messages, and every tool action. The cycle was:
Run baseline rollouts with a versioned task and verifier.
Inspect trajectories, failed tool calls and verifier diagnostics.
Identify ambiguous instructions, unproductive actions and wrong tool choices.
Revise the agent's skills and MCP tool descriptions.
Rerun the same tasks under the same conditions and compare verified outcomes and efficiency per success.
According to Figure 2, a coding agent drove this process with a human in the loop. The post names two concrete changes: overlapping file and shell interfaces were simplified, so the agent had fewer near-duplicate tools to choose between, and tool inputs were given explicit JSON schemas. The post does not list the individual skill edits.
Results
The benchmark used 7, an open-source 180 nm PDK, whose full dataset has 229 standard cells across 36 PVT corners. Solido AFS handled SPICE simulation. For tuning, each run was cut to 2 cells × 36 corners and still took 1.5 to 2 hours. The team ran roughly 25 rollouts in total.
Metric
Before
After
Mean composite score
~55%
~95%
Agent turns
155
53 (−66%)
Output tokens
~81K
~29K (−64%)
The efficiency gain matters as much as the score. Fewer turns and tokens mean lower cost and less wall-clock time, and the run has fewer chances to drift off course.
What to make of it
The authors' broader recipe is to grade final artifacts rather than individual tool calls, write a domain-specific verifier that catches missing, truncated, reformatted or reused results, and collect many rollouts to tune skills and tool interfaces. That generalises well beyond chips. It treats tool descriptions as an interface you test against a fixed evaluation, the same way you would test any other code.
The evidence is thinner than the headline numbers suggest, and this is a vendor post:
Small sample. About 25 rollouts were spread across all iterations, so each version got only a handful. No variance or confidence intervals are reported.
No held-out set. The same tasks were used both to tune and to measure, so some of the gain could be overfitting to two cells on one PDK.
Subset only. No result is given for the full 229-cell library, or for other PDKs or models.
Unclear baseline. It isn't stated whether "55%" means many runs scoring zero on a gate or consistently partial accuracy. That distinction matters for how the agent fails in practice.
Also left open: which individual changes produced most of the gain, and whether the tuned skills transfer when the underlying model changes.
Remember
Silent errors in multistage agent workflows only show up when you grade the final artifact, not each tool call.
Multiplicative pass/fail gates, including an integrity check, give zero reward to agents that copy or truncate results.
Simplifying overlapping tools and adding JSON schemas cut turns from 155 to 53 on the same model.
Latent Space interviewed Ian Quigley of Leash Bio, a company that measures which small molecules bind to which proteins at very large scale. Leash also announced Minos, an environment where AI agents run simulated lab experiments, released with a preprint and an open dataset. What's published is the episode's show notes, not a transcript, so most points below are claims without the methods behind them.
How the data is made
Leash uses 1. Each molecule in a huge combinatorial collection carries a DNA barcode. You expose the pool to a protein, wash off whatever doesn't stick, and sequence the DNA that remains to see which molecules bound. DELs have a reputation for noisy results. One common failure is a protein binding the DNA barcode instead of the molecule. Leash catches this by putting dozens of barcodes on each molecule. Quigley's rule is that biology only scales two ways: taking pictures and sequencing DNA.
Evidence that binding isn't solved
2 contest. Leash released about 4 billion measurements and drew about 2,000 teams. On a chemical library the models hadn't seen, nobody beat chance.
3 in 4. ChEMBL is a public database of bioactivity results. Clever Hans was a horse that seemed to count but was reading its handler's cues. Leash found that models can tell which chemist made a molecule from its structure, and that "who made it" predicts activity about as well as the structure does.
Hermes vs. 5. Hermes, trained only on Leash's own data, reportedly keeps pace with Boltz, an open-source model that predicts protein–molecule structures, on public benchmarks. But Boltz had already seen one benchmark 6 molecule in its training data.
Breaking the pocket. Hermes was memorizing protein "nicknames" instead of learning binding sites. Leash's response was to engineer protein mutants at scale, so the shortcut stops working.
Minos
Every answer in Leash's data is a real measurement, so it can be used to grade an agent's reinforcement-learning attempts. In Minos, LLM agents reason in plain English about 7, meaning how changes to a molecule's structure change its potency. The task is to find the best binders among 6.5 million molecules with a budget of 100 tests. The notes don't give scores for any model. Those are presumably in the preprint.
Also covered
The episode also covers going from a DEL hit to good drug behavior in mice in six months on an inflammation program, Quigley's case for pills over antibodies against cytokine targets, and the "Kosuri paradox": if you can collect the data, why do you need a model? The common thread is that on scientific benchmarks, the strongest signal is often a shortcut, and you only find it by building tests designed to break it.
Latent Space, a podcast and newsletter about AI engineering, has published an interview by Brandon Anderson with Ian Quigley of Leash Bio. Leash generates large amounts of data on which small molecules bind to which proteins. The episode came with news. Near the end of the recording, Quigley described an environment his team had only just started trying: their experimental data turned into tens of thousands of "lab-in-the-loop" simulations, where an agent proposes experiments and gets real measured results back. Two months later that environment is called Minos, and Leash has released a preprint, a blog post and an open dataset alongside the episode.
What's published is the episode's show notes, not a transcript. Most points below are topics listed in those notes, and the notes say little about methods. Take this as a map of the claims, not the evidence for them.
The data engine: DNA-encoded libraries
Leash works with 1. A DEL is a huge combinatorial collection of small molecules, each tagged with a DNA barcode. You expose the pool to a target protein and wash away whatever doesn't stick. Then you sequence the remaining DNA, which tells you which molecules bound. Anderson says the general trick is to map a problem onto a combinatorial library plus a sequencing readout. This matches Quigley's rule that biology scales in only two ways: taking pictures and sequencing DNA.
Anderson says DELs have a bad reputation for noisy results that don't reproduce, and that they "traumatize everyone who touches them". One failure mode named in the notes is a protein binding the DNA barcode instead of the drug-like molecule, which produces a false hit. Leash's fix is to attach dozens of barcodes to each molecule, so binding driven by the DNA can be spotted and thrown out. Anderson credits Leash's clean, reproducible data to "epistemic rigor" and a willingness to just do the work.
Evidence that binding isn't solved
2 competition. Leash ran a public machine-learning contest on Kaggle, a data-science competition platform. It released about 4 billion measurements, generated in what the notes call "a basement", and about 2,000 teams entered. When models were tested on a chemical library they hadn't seen during training, no one beat chance. Models that look good on familiar chemistry fall apart on new chemistry. Quigley also says Leash privately worried that co-folding models would make its data obsolete.
3 in 4. ChEMBL is a large public database of bioactivity results taken from the literature. Clever Hans was a horse that seemed to do arithmetic but was really reading cues from its handler. Leash found something similar: a model can guess which chemist made a molecule from its structure alone, and knowing "who made it" predicts the molecule's activity about as well as the structure does. So a model trained on public data can score well by learning which labs make good compounds, not by learning chemistry.
Hermes vs. 5. Leash's own model, Hermes, is trained only on Leash's data. According to the notes it keeps pace with Boltz, an open-source co-folding model, on public benchmarks. The notes also mention a 6 molecule (BRD4 is a common cancer-related target) that Boltz had already seen in the Protein Data Bank. That is a leak from training data into the test set, and it inflates benchmark scores.
Breaking the pocket. Hermes had its own shortcut. It was memorizing "nicknames" for proteins, meaning it recognized which protein it was looking at instead of learning the binding site. Leash's response was to engineer protein mutants at scale. If you change the pocket and the model's prediction doesn't change, the model wasn't looking at the pocket.
The notes also mention a side finding: hits that resemble lumacaftor, a cystic-fibrosis drug that helps a misfolded protein fold correctly, turned up as an accidental detector of misfolded proteins in the screens.
Minos: an environment for agents
Leash's data makes good reinforcement-learning material because every answer can be checked against a real measurement. In the sandbox described in the episode, LLM agents reason about 7, meaning how changes to a molecule's structure change its activity, in plain English. The task is to find the best binders among 6.5 million molecules while only being allowed to "test" 100 of them.
Here is an illustrative way to read that budget (not from the article): testing at random means sampling about 0.0015% of the library. An agent that does better has to form hypotheses ("this scaffold binds, so try its neighbors") and update them as results come back, much as a medicinal chemist would. Because the answers are measured outcomes and not model predictions, the reward can't be gamed by convincing reasoning alone. The notes don't report how current models score. Those results are presumably in the preprint.
Drug discovery and strategy
The episode also covers:
The Recursion mafia. Recursion is a drug-discovery company built on automated lab work. Its alumni have founded companies that, Quigley says, "all rhyme".
The Kosuri paradox. If you can collect the data directly, why do you need a model at all?
A real program. On an inflammation program, Leash went from a DEL hit to good 8 in mice in six months. PKPD is pharmacokinetics/pharmacodynamics: how the body handles a drug and what the drug does. Quigley argues for pills over antibodies against cytokine targets.
What's open
The show notes report conclusions without the methods behind them. They don't give the Kaggle evaluation protocol, Hermes's benchmark numbers, or any results for agents in Minos. The preprint and open dataset are where to check those claims. The main lesson for anyone building with models is still clear: on scientific benchmarks, the most predictive feature is often a shortcut, whether that's the author, a protein's identity, or a training-set leak, and you only find out when you build tests designed to break it.
Remember
In Leash's Kaggle contest, about 2,000 teams failed to beat chance on an unseen chemical library.
In ChEMBL data, a molecule's author predicts its activity about as well as its structure does, which models can exploit.
Minos gives agents 100 tests to find the best binders among 6.5 million molecules, graded against real measurements.
Simon Willison has linked to a post by indie game developer Popcar about a recent wave of AI-assisted 1. People are using AI to turn shipped game binaries back into readable source code. Willison highlights it because it covers both the upside and the risk.
The source is a short link-blog entry. It names no specific models or tools and gives no numbers on accuracy or scale.
Why this used to be hard
Compiling a program strips out names, comments and most of its structure. Rebuilding maintainable source from the machine code has traditionally been slow, expert work. Community projects such as the Super Mario 64 decompilation took volunteer teams years to write C code that compiles back to the original bytes. Once done, they enabled native PC ports and mods.
Popcar's claim is that AI has made this cheap enough to produce a wave of decompiled games, not a handful. The post doesn't say how. A reasonable guess, not stated in the article, is that models handle the tedious step of reading low-level code and rewriting it as clean source. Recompiling and comparing against the original binary then gives an automatic correctness check.
The upside
Popcar calls it "a big win for preservation." With source in hand, old games can be "ported, modified, enhanced, and made much more easily accessible." Many projects target new hardware, often the browser through 2, a portable format that runs compiled code at near-native speed in a web page. Source access also enables "weird mashups" that combine different games.
Popcar connects this to ownership. Consoles are going digital-only, and games become unplayable when servers shut down. So "we could own software we bought regardless of what the company thinks."
The scary part
Nothing about this is specific to old games. "If AI can decompile games and software, then the entire tech industry is about to explode," Popcar writes. Companies could take code from competitors, and "your paid game or app can be open-sourced against your will." For engineers, that challenges the quiet assumption that shipping a compiled binary keeps the implementation private in practice.
What's missing
There's no evidence yet on output quality, or on whether the approach scales from small old console games to large, heavily optimized modern codebases. Copyright law still applies whatever tool did the decompiling. Read this as a practitioner's report of a trend, not a measured result.
Simon Willison has linked to a post by indie game developer Popcar, who describes a recent wave of games being decompiled with AI help. People are reconstructing source code from shipped game binaries. Willison picked it out because it covers both sides: a boom in game preservation and odd creative mashups on one hand, and a real threat to anyone who ships closed-source software on the other.
The source material is thin. It's a short link-blog entry with a few quoted passages. It doesn't name the models, tools or projects involved, and it gives no figures on speed, accuracy or how many games have been decompiled. What follows is the argument as presented, plus the general background needed to follow it.
The problem 1 solves
When a program is compiled, most of what makes source code readable disappears. Variable and function names go, comments go, and high-level structure gets flattened into machine instructions that the optimizer has shuffled around. Turning that back into source a human can maintain has historically been slow, skilled work. Tools like disassemblers and 2 (the US National Security Agency's open-source reverse-engineering suite) produce rough pseudo-C. A person still has to work out what each function does, name it, and rewrite it cleanly.
The most ambitious game efforts, such as the community decompilation of Super Mario 64, aimed for "matching" decompilation. That means hand-written C that compiles back to the exact original bytes, which proves the reconstruction is faithful. These projects took teams of volunteers years. Once they finished, the payoff was large: native ports to modern PCs, mods, and fixes the original developers never made.
What changed
Popcar's claim is that AI has made this process far cheaper, enough to produce a "recent wave" of decompiled games instead of a handful of labors of love. The article doesn't explain the mechanism. A plausible reading, and it is an inference rather than something the post states, is that language models are good at the tedious middle step: reading low-level pseudo-code, guessing what a function is for, and rewriting it as idiomatic source. For 3, the original binary also gives a built-in correctness check. Compile the candidate code and compare the bytes. That gives a model a tight loop of trying, checking and fixing.
The upside: preservation and remixing
Popcar sees a big win for preservation. Once a game exists as source, it can be "ported, modified, enhanced, and made much more easily accessible than before." Willison notes that many of these projects target new hardware, often the browser via 4, a portable low-level format that lets compiled code run at near-native speed in a web page. Source access also enables the "weird mashups" Popcar mentions, with pieces of different games combined.
Popcar ties this to ownership. With console makers "going all in on digital" and games becoming "entirely unplayable due to servers shutting down," decompilation means "we could own software we bought regardless of what the company thinks."
The downside: no binary is safe
The same capability isn't limited to old games. Popcar puts it bluntly: "If AI can decompile games and software, then the entire tech industry is about to explode." In this view, anyone can decompile other software and use it however they like. Companies can lift code from competitors, and "your paid game or app can be open-sourced against your will."
For engineers, this undercuts an assumption many business models quietly depend on: that shipping a compiled binary keeps the implementation private in practice, even though it was never private in principle. 5, server-side logic and licensing law are still available. If Popcar is right, the cost barrier that made those defenses rarely necessary is going away.
What remains open
The piece leaves the important questions unanswered:
How good is the output? There is no data on whether AI-produced decompilations match the originals, compile cleanly, or still need heavy human cleanup.
How general is it? Old console games are small, often unoptimized, and written in C. Whether the approach scales to large modern C++ codebases or heavily optimized binaries isn't addressed.
The law. Copyright on the original code still applies whatever tool did the decompiling. The post treats "nobody can stop them" as a practical claim, not a legal one.
Treat this as a practitioner's report of a trend, not a measured result. The reasoning holds up, but the scale of the shift hasn't been shown here.
Remember
Decompiling a binary against the original gives a built-in check: recompile the result and compare the bytes.
Preservation projects increasingly port decompiled games to browsers through WebAssembly.
The post offers no data on accuracy or scale, so it is a reported trend, not a measured result.
A conference for practitioners building products on large language models; the talks covered here were given there.
Two Sigma slide from the classifier section: classifiers for ambiguous cases, deterministic rules for clear ones.1 / 4
At this week's AI Engineer New York conference (AIE NY), a practitioner event for people building with language models, OpenAI, Anthropic, the hedge fund Two Sigma and Bloomberg all spoke about one problem: how much autonomy to give AI agents that touch money. Richard MacManus, writing in Latent Space, sums up their shared answer: what matters is where you put controls and human judgment, not how many restrictions you pile on. The piece is a conference recap, so it offers frameworks and anecdotes, not measurements.
OpenAI: the threshold of usefulness
Joseph Kim, who runs ChatGPT for Financial Services, talked about a "threshold of usefulness": the point where a model is reliable enough that handing it work saves time instead of costing time in checking. He predicted that in 2027, finance will lean less on Excel and PowerPoint and agents will handle "investment idea generation and trading." He gave no evidence for this in the talk as reported. His practical point was traceability: analysts need to see where every number came from. He treated the question of what humans still review or approve as a product design decision.
Two Sigma: avoid 1
John Feminella, Two Sigma's SVP of Architecture, warned against approval fatigue: if a person must approve everything, work slows and the person stops paying attention. Two Sigma uses five composable controls, each doing one job. The recap names only one: 2. These are models that handle routine agent requests and send humans only the ones most likely to matter. His split: classifiers for ambiguous cases, fixed 3 for clear-cut ones.
Anthropic: a trust layer
Keon Shahab from Anthropic's applied AI team described three parts:
an identity and permissions layer that defines who the agent acts as
a 4 plus approval step, so someone signs off before the agent acts
testing that the agent still works as things change over time
His example was an agent that investigates 5, which are mismatches between two parties' records of a trade. The agent proposes a fix to the orders data, and a human applies it.
Bloomberg: controls outside the model
Andrey Rybka from Bloomberg's Office of the CTO described real incidents where agents caused damage. In one, an agent read instructions hidden in a marketplace product review as an order to stock the product. This is a 6 attack. His defenses: scoped credentials, checks on tool calls, outbound traffic limits, audit trails, budgets and kill switches. "We want deterministic controls outside the model. Check every call, log it, and keep a kill switch." Code like that holds no matter what the model has been tricked into believing.
The common pattern
All four keep proposing separate from acting, scope permissions tightly, and save human attention for the decisions that matter. Feminella's line: brakes exist "so that you can go fast and stop safely."
This week's AI Engineer New York conference (AIE NY), a practitioner event for people building with language models, kept coming back to one question: how much autonomy can you give an AI agent when it works with money? Two frontier labs, OpenAI and Anthropic, spoke alongside two financial firms, the hedge fund Two Sigma and Bloomberg. Writing for Latent Space, Richard MacManus sums up what they shared: safe autonomy depends on where you put controls and human judgment, not on how many restrictions you add.
The piece is a conference recap. It gives no evals, incident rates or measurements, just the speakers' frameworks and one concrete failure. Read it as a set of design patterns, not evidence.
OpenAI: the "threshold of usefulness"
Joseph Kim, Head of ChatGPT for Financial Services at OpenAI, built his keynote around a "threshold of usefulness": "the point where a model becomes capable and reliable enough to save you time." Below that point, checking the agent's work costs more than doing the task yourself. Above it, delegating pays off. Kim argued that rising model capability will soon push financial analysts past that point.
He made specific predictions for 2027. The industry will rely less on Excel and PowerPoint, and agents will be good enough for "investment idea generation and trading." He gave no supporting data in the talk as reported.
His more concrete point was about traceability. "In finance, you need to be able to check where a number came from and understand the context around it," he said. OpenAI wanted that review to be "a natural part of" the product. He treated human oversight as a product design problem: "How would the interface change? What would the user still need to control, review, or approve?"
Two Sigma: composable controls and 1
John Feminella, SVP Architecture at Two Sigma, described five controls the firm uses to "keep agents in check without limiting model capabilities." He rejected the idea that safety and innovation are opposite ends of one scale. His main target was approval fatigue. If a person has to approve everything, the work slows down. Worse, the person stops paying attention, so the approval step itself becomes a risk.
He calls the controls "guardrails and shared capabilities." They are composable: "each one does one job and then together they let us run agents with real autonomy at an appropriate level of safety." Think of Unix pipes (an analogy, not his): small single-purpose pieces you can chain, rather than one monolithic gate.
The recap names only one of the five controls: 2. These are models that sort an agent's requests, handle the routine ones, and pass to a human "only the requests that are most important, the ones that are most likely to make a difference." Feminella split the job between two tools. Use classifiers for ambiguous cases, and 3 (fixed, hard-coded checks) for clear-cut ones. For an illustrative example not taken from the talk: a hard rule could block any write to a production trading system, while a classifier decides whether a particular data query looks unusual enough to show a person. The article doesn't describe the other four controls.
Anthropic: identity, approval, and staying reliable
Anthropic launched Claude for Financial Advisors last month, which connects advisors' systems to Claude plus a set of workflow skills. Belinda Neal, Managing Director of Financial Services, used the same threshold framing as Kim: "Every so often, a model crosses a threshold. And when it does, a wave of working changes."
Keon Shahab from Anthropic's applied AI team described a three-part "trust layer":
Identity and permissions: who the agent is acting as, and what it is allowed to do.
Sandbox and approval: confining the agent so "someone is signing off before it acts."
Ongoing reliability: knowing the agent "will still work once we adjust any variables over time." This means regression testing as models, prompts or data change.
His example was a 4 investigation agent. A trade break is a mismatch between two parties' records of the same trade. The agent investigates and proposes an amendment to the orders data, but a human applies it. "We want it to just propose new amendments to our orders data, not actually make those amendments." Shahab's argument is that if you build this base layer once, you can deploy many agents quickly on top of it.
Bloomberg: enforce it outside the model
Andrey Rybka, Head of Architecture & Emerging Technologies in Bloomberg's Office of the CTO, went through real incidents where agents caused damage. He listed these defenses:
scoped identities and credentials
controls on tool calls
restrictions on outbound network traffic
audit trails
budgets
kill switches
His sharpest example was 5, where hostile text in the agent's input gets treated as a command. An agent read instructions hidden in a marketplace product review as an order to stock that product. His fixes were input validation, prompt-injection defenses, 6 (recording where each piece of input came from) and human approval for high-value actions.
His principle: "We want deterministic controls outside the model. Check every call, log it, and keep a kill switch." The reasoning is that you can't count on the model to police itself, because injected text arrives in the same channel as legitimate instructions. A check in ordinary code doesn't care what the model was persuaded to do.
What lines up, and what's missing
The four talks largely agree:
Separate proposing from acting.
Scope permissions to a specific identity.
Use hard rules for the clear cases.
Save human attention for the decisions that matter, and use classifiers to find them.
Log everything and keep a way to stop the agent.
Feminella summed it up: "Why do cars have brakes? It's not just so that you can stop, it's so that you can go fast and stop safely." MacManus concludes that even as the labs build trust frameworks, putting controls around agents is ultimately each financial firm's job.
The recap leaves several things open:
How accurate Two Sigma's classifiers are, and what happens when they wave through a request that should have gone to a person.
What the other four controls are.
How often Bloomberg's incidents happened.
Whether Kim's 2027 trading prediction rests on anything beyond the capability trend.
A podcast with Kim is due soon and may fill in some of this.
Remember
Approving everything is not safe. Overloaded reviewers rubber-stamp, so send humans only the decisions that matter.
Use hard-coded rules for clear-cut cases and classifiers for ambiguous ones. Neither works well alone.
A review containing hidden instructions fooled an agent. Put checks, logging and kill switches in code outside the model.
X-SHiELD is a global atmospheric model from NOAA's Geophysical Fluid Dynamics Laboratory. It runs at a few kilometres resolution, fine enough to simulate storms directly. Here it serves as both the training data and the benchmark.
A strong North Atlantic hurricane from the 10-year HiRO-ACEv2 run, with eye and rain bands resolved.1 / 3
The Allen Institute for AI (Ai2) has released HiRO-ACEv2, a pair of neural networks that generate global weather data at 3 km resolution. Ai2 says it costs about 1/300th as much as 1, the physics simulation it was trained to imitate, and keeps the extremes intact. The models, a paper, notebooks and a demo are public.
The problem
At 3 km per grid cell, a model can resolve hurricane eyes, rain bands and winds racing down mountain slopes. X-SHiELD, a storm-resolving global model from the US weather agency NOAA, works at that scale. But running it for decades, or many times over to sample natural variability, is very expensive. A cheap substitute is only useful if it keeps the rare, intense events, and by definition those are scarce in the training data.
How it works
The system has two stages:
2 is an AI model that steps the global atmosphere forward at a coarse 100 km resolution. It's cheap enough to run for 10 years or more.
3 is a 4. It takes ACE's coarse fields and generates matching 3 km detail.
Both learned from X-SHiELD. The v2 change is mostly in the downscaler. HiROv1 predicted only rainfall, while HiROv2 predicts rain, wind and sea-level pressure together. Ai2 says changes to its training improved how it handles the most intense values, but the post doesn't say what those changes were.
Results
Given coarsened X-SHiELD data as input, HiROv2 matches X-SHiELD's fine-scale statistics to within 3%, even for one-in-a-million events.
It accurately estimates total tropical cyclone energy, including for storms it never saw in training. Its hurricanes have realistic eyes and rain bands, though winds and pressure around the eye are more lopsided than in X-SHiELD.
In the harder full test, HiRO downscales ACE's own free-running simulation rather than X-SHiELD data. A year of global 3 km output closely matched X-SHiELD's statistics. Over 10 years, total hurricane energy was comparable.
The 3% figure comes from the easier test. The post gives no comparable number for the full chain.
Cost
Global output is about 300× cheaper than running X-SHiELD. When only one region is needed, the savings can be more than 100 times greater again. A version of HiROv2 that could be more than 10× faster is in development.
Limits
The system only reproduces the climate it learned. HiRO works only with the version of ACE tuned to X-SHiELD, so it can't yet downscale a warmer future or historical records such as 5, a standard reconstruction of past global weather. Ai2 plans to train on new X-SHiELD runs, including a world 4°C warmer, and to add temperature, snow and ice outputs.
The Allen Institute for AI (Ai2) has released HiRO-ACEv2, an update to its system for generating high-resolution global climate data with neural networks instead of a full physics simulation. Ai2 says the system produces global data at 3 km resolution for about 1/300th the cost of 1, the physics-based atmospheric model it learned from. It also says it reproduces even very rare rain, wind and pressure extremes closely. The models, a paper, tutorial notebooks and a web demo are all public.
The problem
Researchers who study extreme weather in a changing climate need long records at fine resolution, ideally many versions of them. Hurricane eyes, rain bands and winds pouring down mountain slopes only show up at a few kilometres per grid cell. X-SHiELD, a global model from NOAA's Geophysical Fluid Dynamics Laboratory, runs at that scale and simulates storms directly. But running it for decades, or for many 2 (repeated runs that sample natural variability), is very expensive.
Emulation is tricky precisely because the extremes are the point. A model that gets average rainfall right but smooths away the heaviest downpours is useless for flood or hurricane research, and those tail events are by definition rare in the training data.
How the system fits together
HiRO-ACE (High Resolution Output Ai2 Climate Emulator), first introduced earlier in 2026, has two parts:
3, an AI model that steps the global atmosphere forward through time at a coarse 100 km resolution. Because it's cheap, it can run for 10 years or more.
4, a downscaling model. It takes ACE's coarse fields and generates plausible 3 km detail consistent with them.
An analogy (ours, not Ai2's): ACE sketches the weather map in broad strokes, and HiRO paints in the fine texture a trained eye knows goes with each stroke. Both learned from X-SHiELD. ACE was tuned to match X-SHiELD's coarse behaviour, and HiRO learned how X-SHiELD's fine detail relates to a coarsened version of the same fields.
What changed in v2
The main change is the 5, HiROv2. Version 1 predicted only rainfall. HiROv2 predicts several high-resolution fields at once: precipitation, wind and sea-level pressure. That lets it capture a wider range of extremes, such as windstorms and the pressure structure of cyclones. Ai2 says changes to how HiROv2 is trained improved its handling of the most intense values, but the blog post doesn't describe those changes or the architecture. They are presumably in the technical report. Ai2 also trained an updated ACE for this system.
Results
Ai2 tested the parts separately and then together.
HiROv2 alone, given coarsened X-SHiELD data (an "oracle" test with perfect coarse input):
It matches X-SHiELD's high-resolution statistics to within 3%, including for events that occur once in a million data points.
It accurately estimates the total energy of tropical cyclones, including storms it never saw in training.
Its hurricanes have realistic eyes and rain bands. The winds and pressure around the eye are more lopsided than in X-SHiELD, which Ai2 notes as a remaining flaw.
It realistically produces strong downslope winds over mountains.
ACE alone, over a 10-year simulation: its hurricanes, average climate patterns, and distributions of rain, wind and pressure "line up well" with X-SHiELD. Ai2 takes this to mean ACE is a sound base for long high-resolution runs. The post gives no specific error figures for this part.
The full chain: this is the harder test, because HiRO now works from ACE's own free-running simulation rather than real X-SHiELD data. Any errors ACE builds up feed straight into the downscaler. Ai2 generated a full year of global 3 km data and reports that its statistics closely match X-SHiELD's. Across a 10-year run, total hurricane energy was comparable to X-SHiELD's over the same period, and snapshots show various other extremes that resemble X-SHiELD's. One example is a strong North Atlantic hurricane.
Cost
Global high-resolution output costs roughly 300 times less than running X-SHiELD. When only one region is needed, the savings can be more than 100 times greater again, depending on the area. That's because a physics model generally has to simulate the whole globe, while HiRO only needs to downscale the region of interest from a cheap global ACE run. Ai2 is also building a streamlined HiROv2 that it says could be more than ten times faster still. The post doesn't say what hardware the cost comparison assumes.
Limits
The main limit is that the system can't generalise beyond its teacher. HiRO learned X-SHiELD's fine-scale behaviour, so it only works with the version of ACE tuned to match X-SHiELD. It can't yet downscale other climates, such as a warmer future or the historical record in 6 (the European Centre for Medium-Range Weather Forecasts' reconstruction of past global weather). That matters for climate research, where the question is usually how extremes change.
Ai2's plan is to train on new X-SHiELD runs, including one of a world 4°C warmer. It also plans to add outputs such as near-surface temperature, snow and ice, which would enable uses like snowpack prediction.
Some things the post leaves open. Whether a model trained on a few climates can interpolate between them hasn't been tested. The 3% figure comes from the oracle setting, and the post gives no equivalent number for the full ACE-driven chain. And "comparable" hurricane energy is a statement about statistics in aggregate, not about matching individual storms. Matching individual storms isn't the goal anyway, since a free-running climate emulator produces its own weather, not a forecast of real weather.
Trying it
Ai2's web demo shows pre-generated precipitation, wind and pressure fields from HiROv1 and HiROv2 side by side with X-SHiELD. Users can zoom into a region to judge quality there without running inference. The models can be downloaded, and the notebooks walk through how to run them.
Remember
Splitting the job into a cheap coarse emulator plus a downscaler makes decade-long 3 km runs affordable.
The headline 3% accuracy comes from an oracle test. Full-chain results are described only as "closely match".
An emulator can't produce a climate it never saw: warmer-world output needs new runs of the physics model to train on.
Competition. He discusses what stops a better-funded lab from outscaling Leash, and says that if he could wish one thing into existence it would be massively parallel purification.
