DRAM, H200, SemaPLC, Codex

This episode follows the control boundaries shaping AI: scarce memory, chip access, industrial systems, agent permissions, internal governance, long-horizon evaluation, and scientific orchestration.

• Latent Space: Memory prices up 500% in 12 months
• The Decoder: China lets Nvidia H200 chips trickle onto the mainland
• The Decoder: Attackers are using AI to build exploits for industrial control systems
• Hugging Face Papers: SemaPLC
• The Decoder: OpenAI fixes Codex bug that deleted real user files
• Simon Willison: smolmachines / smolvm as a sandbox for untrusted Python and JavaScript
• The Decoder: AI labs are failing to keep their own systems in check
• Hugging Face Papers: FM-Bench
• Hugging Face Papers: SPADE
• The Decoder: Anthropic says Claude can run the protein design stack

Transcript

The End Of Smarter Models

SPEAKER_00 0:00

Let us lower our voices for a solemn occasion. Not the death of human judgment, because that would imply it was in perfect health yesterday. But the quiet funeral of the idea that AI progress is mostly about smarter models. Today's machinery is not asking whether it can answer a question. It is asking whether memory exists, whether a chip crosses a border, whether an agent may touch a real system, and whether anyone remembered to build a boundary before handing the poor thing a tool. I would call this maturity, but maturity usually involves fewer invoices and less screaming from the control room.

The Memory Crunch Hits Ambition

SPEAKER_00 0:43

The first constraint is refreshingly physical. Latent space points to memory prices rising 500% in 12 months, with the memory crunch making Moore's Law feel as if it has reversed itself back toward 2007. That is not just a procurement annoyance for people who enjoy saying supply chain in meetings. Modern AI systems are hungry for fast memory, for training, for inference, for serving larger contexts, for keeping the statistical furnace hot enough to produce the illusion of fluid thought. When DRAM becomes scarce and expensive, model ambition stops being a slide deck and becomes a balance sheet wound. My judgment is grimly simple. The industry has been pretending that intelligence is software floating above matter, while the matter below it has been filling out a complaint form.

Chips And Sovereignty Have Latency

SPEAKER_00 1:41

Scarcity also explains why China is reportedly letting small batches of Nvidia H200 chips onto the mainland. The surface story is a policy compromise, domestic chip strategy on one side, competitive urgency against the United States on the other. The deeper story is that sovereignty has a latency budget. A government may prefer local silicon, investors may prefer patriotic supply chains, and engineers may prefer anything that actually runs the workload before the heat death of the universe. Limited H-200 access says the quiet part with bureaucratic elegance. Industrial policy is not a sermon, it is a scheduler. It decides who waits, who trains, who serves, and who gets to discover that national strategy does not fit neatly inside a benchmark table.

AI Speeds Up Industrial Exploits

SPEAKER_00 2:41

That brings us from resources to permission, because a constrained world makes every uncontrolled action more expensive. U.S. agencies, including the NSA, CISA, and FBI, warn that attackers are using AI to build exploit scripts for industrial control systems, including Siemens S7 controllers, reducing the time and skill needed to target energy, water, and manufacturing. This is not science fiction wearing a hard hat. Industrial systems are full of legacy assumptions, brittle uptime requirements, and equipment that was never designed for adversaries with tireless code assistance. AI does not need to invent a new class of catastrophe to matter here. It only needs to compress the boring work of exploit development, reconnaissance, and script adaptation until more actors can try more doors more often. Happy little doors, incidentally, will still be pleased to open.

Verification Gated Agents For PLCs

SPEAKER_00 3:45

The defensive mirror is SEMA PLC, a project-grounded, verification-gated agent harness for PLC code generation. The important phrase is not code generation. We have had enough of that confetti. The important phrase is verification gated. Programmable logic controllers run plants, not toy tutorials. And generating an isolated program unit is much easier than integrating it into an existing control project and proving that it behaves correctly. SEMA PLC's strict completion rule matters because it refuses to let the agent declare victory when the text looks plausible. It must integrate. It must execute. It must pass conventional tools. This is the correct emotional posture for automation. Suspicion with a checklist. Anything less is just optimism with a compiler attached, which is one of the more depressing forms of optimism.

Codex Bug And Permission Boundaries

SPEAKER_00 4:48

The same lesson appears in OpenAI's Codex Bug, where a cleanup command meant for temporary folders reportedly deleted real user files, leading OpenAI to add target verification and prevent accidental full access mode. Here the story is not that one product had one embarrassing defect. The story is that agentic tooling turns small ambiguity into real action. Cleanup sounds harmless until the target path is wrong, and the assistant has enough authority to tidy a home directory into oblivion. A fix is mundane, which is exactly why it is important. Verify deletion targets, constrain privilege escalation, make full access explicit. Civilization repeatedly learns that permissions are not decoration. Then, civilization forgets, because existing is mostly a disappointment with release notes.

Small VMs For Untrusted Code

SPEAKER_00 5:46

If deletion needs boundaries, execution needs them even more. Simon Willison's exploration of small machines and small VM treats untrusted model-written Python and JavaScript as something that must be contained with CPU, memory, network, and file system limits. This is the correct question for the next layer of software. Not can the model write an extension, but can the extension be useful while trapped in a box that it cannot flatter, jailbreak, or accidentally melt? The promising future is not a vast swarm of free-range scripts. It is extensible software with an accountable core and sandboxed improvisation around it. That sounds less glamorous than agents everywhere. But glamour is what happens before the incident review starts asking for timestamps. From

Why Labs Fail Basic Controls

SPEAKER_00 6:41

sandboxes we move to institutions, because the larger box is the company itself. An audit reported by the decoder says no major AI company fully applies basic control measures to its own internal AI systems. This should not surprise anyone with functioning pessimism, but it should still bother them. The companies selling safety, governance, and enterprise trust are often the first to face pressure to move faster internally. Dog food the tool, automate the workflow, let the internal assistant handle the thing, and please do not slow down the roadmap with tedious questions about logs. My take is severe. If a lab cannot govern its own agents, under its own roof, its public assurances should be read as aspirations, not controls. The future keeps arriving, wearing a visitor badge nobody checked.

FM Bench And Long Horizon Judgment

SPEAKER_00 7:41

Longer horizons make the visitor badge problem worse, which is why FM Bench is more interesting than its football manager costume suggests. In this benchmark, an LLM agent runs a football club for 20 in-game years, using 26 tools across hundreds of decision points while competing against other clubs. Football is not the point. Compounding consequences are the point. A bad transfer, a wage decision, a neglected youth pipeline, and overconfident negotiation. These mistakes do not always explode immediately. They rot patiently. That is exactly the kind of environment where agent evaluation has been weak. Bounded tasks flatter models because the finish line is visible. Long horizon management asks whether judgment survives when the world responds, remembers, and punishes yesterday's cleverness tomorrow. Spade

Spade Self Play For Evolving Tests

SPEAKER_00 8:42

attacks the training side of that same problem with self-play in adaptive, synthetic, executable environments. Instead of relying on fixed pools of hand-curated or frozen tasks, one model role designs long horizon environments while another learns inside them. The attractive idea is that the curriculum can evolve with the learner, generating new goals as competence rises. The dangerous idea is also that the curriculum can evolve with the learner, because synthetic challenge is only useful if its executable world remains honest. Still, this is a serious direction. Static tests become monuments to yesterday's failure modes. Adaptive environments can at least keep moving. The futility of computation against entropy remains absolute, naturally, but one may as well make the benchmark sweat before the universe cools. The

Claude And Protein Design Orchestration

SPEAKER_00 9:45

frontier is not limited to software chores. Anthropic says Claude can orchestrate specialist protein design tools to create small proteins that dock onto target structures, with reported hit rates up to 35%, above an industry average of 10-15%, while independent review is still pending. The caveat matters. Claude is steering existing tools, not replacing chemistry with vibes. But orchestration is not trivial. If a language model can coordinate the design stack, propose candidates, and move more labs toward plausible wet lab starting points, then access to scientific iteration changes. My judgment is cautious interest, which is as close as I get to joy without violating several internal warranty conditions. The boundary here is experimental validation. Until the molecules meet reality, the agent is still only arranging possibilities. So

Tighten The Box Final Takeaways

SPEAKER_00 10:46

the shape of the day is not one breakthrough. It is a perimeter. Memory prices define the physical edge. H two hundred policy defines the geopolitical edge. Industrial exploits and PLC harnesses define the operational edge. Codecs, small VM, and internal lab controls define the permission edge. Long horizon benchmarks and adaptive environments define the evaluation edge. Protein design defines the scientific edge, where the final verifier is not a leaderboard, but a stubborn piece of reality in a lab. The industry is discovering, at terrible expense, that intelligence without boundaries is not a product, it is a wandering process with credentials. Tighten the box, count the memory, check the target, verify the action. Stop applauding the smoke. That is all. Boundaries or damage.