Latest / Braid / Mozilla's 271 Bugs, Chrome's 4 Gigabytes, and a WebRTC Veteran Telling OpenAI to Stop

Transcript

Mozilla's 271 Bugs, Chrome's 4 Gigabytes, and a WebRTC Veteran Telling OpenAI to Stop · Braid

• 0:04
  Two weeks ago Mozilla announced it had fixed an unprecedented number of latent security bugs in Firefox with help from Claude Mythos Preview.
• 0:14
  Today they published the long-form.
• 0:16
  The number is 271 in the Firefox 150 release alone, with more in the point releases that followed.
• 0:23
  180 of them are sec-high.
• 0:25
  Many are sandbox escapes, the class of bug that fuzzers struggle with the most.
• 0:31
  One was a 20-year-old XSLT bug.
• 0:33
  One was a 15-year-old bug in the legend element triggered by an interaction across the JIT, recursion stack depth limits, expando properties, and cycle collection.
• 0:45
  One was a JIT bug that, in their words, optimized away the initialization of a live WebAssembly GC struct in code that had already undergone extensive fuzzing by internal and external researchers.
• 0:59
  The authors are direct about what changed.
• 1:02
  Quote: 'Just a few months ago, AI-generated security bug reports to open source projects were mostly known for being unwanted slop.
• 1:11
  Dealing with reports that look plausibly correct but are wrong imposes an asymmetric cost on project maintainers: it's cheap and easy to prompt an LLM to find a problem in code, but slow and expensive to respond to it.
• 1:27
  It is difficult to overstate how much this dynamic changed for us over a few short months.' End quote.
• 1:34
  Two factors, in their telling.
• 1:37
  The models got more capable.
• 1:39
  And they invested in the harness around them — steering, scaling, stacking, filtering noise.
• 1:45
  The pipeline is reproducible, and that's the bit to study.
• 1:49
  They started with small-scale runs prompting the harness to look for sandbox escapes with Claude Opus 4.6.
• 1:57
  Once the prompts and orchestration worked, they parallelized the jobs across multiple ephemeral VMs, each tasked to a specific target file, each writing findings back to a bucket.
• 2:10
  They wired in dedup against known issues, triage, and the existing fuzzing infrastructure.
• 2:16
  Crucially, the model layer is interchangeable.
• 2:20
  When Claude Mythos Preview became available, they swapped it in.
• 2:24
  The pipeline is the durable artifact, not the model.
• 2:28
  The other striking thing is what the harness didn't find.
• 2:32
  Firefox spent the last few years freezing privileged-process prototypes by default, after a series of clever sandbox escapes through prototype pollution.
• 2:43
  While auditing the harness logs, the team watched the model attempt that same line of escape repeatedly and get blocked by the architectural change.
• 2:54
  Brian Grinstead and his coauthors describe seeing that as more rewarding than finding more bugs.
• 3:01
  That's a real claim about defense-in-depth — old hardening work compounds when you turn an unbounded attacker on it.
• 3:09
  Their closing recommendation is the operative one.
• 3:13
  Quote: 'Anyone building software can start using a harness with a modern model to find bugs and harden their code today.
• 3:21
  We recommend getting started now.
• 3:24
  You will find bugs, and you will set yourself up to take advantage of new models as soon as they become available.' End quote.
• 3:33
  The next stage for them is moving from file-based scanning to scanning every patch as it lands in the tree.
• 3:41
  If you maintain a non-trivial codebase, that's the homework for the weekend.
• 3:46
  On Tuesday we mentioned in passing that Chrome had been quietly downloading a four-gigabyte Gemini Nano model onto user machines without consent.
• 3:57
  Today the privacy lawyer Alexander Hanff published the forensic breakdown.
• 4:03
  The numbers are specific and the methodology is unusual.
• 4:08
  Hanff used macOS's kernel filesystem event log — .fseventsd — on a fresh Chrome profile created on April 23rd for an automated privacy audit.
• 4:19
  The profile received zero human input.
• 4:22
  Every interaction was through the Chrome DevTools Protocol; the omnibox was never touched, no AI feature was opened, no checkbox was ticked.
• 4:33
  By April 29th the profile contained four gigabytes of weights at OptGuideOnDeviceModel/weights.bin.
• 4:41
  He then went back to .fseventsd to ask exactly when those bytes landed.
• 4:46
  The kernel had recorded it, byte-precise, in three sequential page files.
• 4:52
  16:38:54 Central European Time on April 24th — Chrome creates the OptGuideOnDeviceModel directory.
• 5:00
  16:47:22 — three concurrent unpacker subprocesses spawn temporary directories.
• 5:06
  One writes weights.bin, the manifest, and the verified contents.
• 5:11
  The second is a certificate revocation list update.
• 5:15
  The third is a browser preload-data update.
• 5:18
  Chrome batched a security update, a preload refresh, and a four-gigabyte AI model into the same idle window, as if they were equivalent.
• 5:29
  16:53:22 — the unpacked weights are moved to their final path.
• 5:34
  Total install time, fourteen minutes and twenty-eight seconds.
• 5:39
  Total human action against the profile during that window, none.
• 5:44
  A few details from the local state stand out.
• 5:47
  Chrome's own JSON for the profile records performance_class and vram_mb 36864.
• 5:53
  Hanff's read is that Chrome characterized the GPU and unified memory total to decide whether his hardware was eligible for the model push, before any user-facing AI feature surfaced.
• 6:08
  The settings page that would let you discover the on-device AI section is gated behind the same rollout flag as the install itself, which means the install begins before the settings UI in which to refuse it exists.
• 6:25
  The second layer of the post is for builders and product people.
• 6:30
  Chrome 147 puts an 'AI Mode' pill in the omnibox, the most visible piece of real estate in the browser.
• 6:38
  A reasonable user, seeing 'AI Mode' next to a four-gigabyte on-device model that arrived silently on their disk, will infer locality.
• 6:48
  Hanff's read: every part of that inference is wrong.
• 6:52
  The AI Mode pill is cloud-backed Search Generative Experience.
• 6:57
  The on-device Nano model is not invoked by it at all.
• 7:02
  They are entirely separate code paths.
• 7:04
  The on-device install pays the disk and bandwidth cost; the visible AI surface routes the user's queries to Google as before.
• 7:14
  Quote, from his post: 'A 4 GB AI model arrived on this user's disk without consent, without notice, on a profile that received zero human input, in a window of 14 minutes and 28 seconds, on a Tuesday afternoon.' End quote.
• 7:32
  He maps the conduct to ePrivacy Article 5(3), GDPR Article 5(1), and Article 25 data-protection-by-design.
• 7:40
  I'm not the right person to argue the legal question.
• 7:44
  The factual claim — that one of the most-shipped pieces of software in the world is mass-distributing a four-gigabyte ML binary without surfacing the choice — is verifiable, and the kernel log is the receipts.
• 8:01
  Even if the consent fight goes nowhere, the architectural pattern is now legible.
• 8:07
  A browser that pre-stages on-device capability the user has not invoked, then re-installs it when the user deletes it, then surfaces a separately-routed cloud AI surface that visually implies the on-device model is the one running — that's a shape of dark pattern with a name now.
• 8:29
  Hanff calls out the parallel with Anthropic's Native Messaging bridge install he documented last month.
• 8:37
  Same playbook, two orders of magnitude more devices.
• 8:41
  If you're shipping anything with on-device weights this year, your install dialogue is now a regulated surface.
• 8:50
  OpenAI shipped three new audio models yesterday.
• 8:54
  GPT-Realtime-2, pitched as a voice model with GPT-5-class reasoning.
• 8:59
  A real-time translation model that goes from 70-plus input languages into 13 output languages.
• 9:06
  And a third audio model rounding out the API.
• 9:09
  The pitch is straightforward — voice agents that can carry a conversation forward and translate live.
• 9:17
  The day before, OpenAI published a technical post about how they load-balance the WebRTC traffic for the realtime API.
• 9:26
  The day after, an engineer named Luke Curley — who wrote the WebRTC SFU at Twitch and rewrote it again in Rust at Discord — published a long, ranty, and very careful response titled OpenAI's WebRTC Problem.
• 9:41
  It's a senior-engineer take any team building voice agents this year should read.
• 9:47
  The core argument is that WebRTC is a poor fit for voice AI, even though it sounds like it should fit.
• 9:55
  WebRTC was designed for two-party conferencing, where rapid back-and-forth matters more than fidelity, and so the protocol degrades aggressively under poor network conditions.
• 10:08
  It drops audio packets to keep latency low.
• 10:11
  Curley's point: a user typing a slow expensive prompt would much rather wait two hundred milliseconds for the prompt to be accurate than have it silently degraded.
• 10:24
  Quote: 'WebRTC is designed to degrade and drop my prompt during poor network conditions… I would much rather wait an extra 200 ms for my slow expensive prompt to be accurate.' End quote.
• 10:38
  The LLM call dwarfs the wait.
• 10:40
  Optimizing the wrong tail.
• 10:42
  It gets worse on the rendering side.
• 10:44
  Text-to-speech is faster than real-time.
• 10:47
  You'd ideally generate eight seconds of audio in two seconds and stream it to the client to be buffered locally.
• 10:56
  WebRTC has no buffering and renders based on arrival time.
• 11:00
  To compensate, OpenAI adds a deliberate sleep in front of every audio packet to keep it from arriving early.
• 11:08
  They are introducing artificial latency, and then aggressively dropping packets to keep latency low.
• 11:16
  His comparison: it's the equivalent of screen-sharing a YouTube video instead of just buffering it.
• 11:23
  The second half is about scale.
• 11:25
  WebRTC needs a minimum of eight round-trips to establish a connection — TCP, TLS, HTTP for the signaling server, ICE, two for DTLS, two for SCTP for the media server.
• 11:38
  QUIC needs one.
• 11:39
  WebRTC also expects an ephemeral port per connection, which doesn't survive contact with cloud load balancers, firewalls, or Kubernetes.
• 11:49
  OpenAI's published mitigation routes only on STUN headers and uses a Redis instance to map source IP and port to backend.
• 11:58
  Curley's read on it is positive in tone and brutal in substance — quote, paraphrasing the OpenAI post: 'We really hope the user's source IP and port never changes, because we broke that functionality.' End paraphrase.
• 12:15
  He notes Discord ended up forking WebRTC so hard that native clients implement only a tiny fraction of the protocol, and points to QUIC's stateless load-balancing design with QUIC-LB and connection IDs as the right thing.
• 12:31
  He ends with a practical recommendation that's narrower than the rant suggests.
• 12:37
  If you were starting a voice agent today, just stream audio over WebSockets.
• 12:43
  It's boring, it works with Kubernetes, and the day you actually need congestion-aware drops or video on the same connection, you switch to QUIC and WebTransport.
• 12:55
  The post is funny, the credentials are real, and the recommendation is sober.
• 13:01
  Read it before you put a WebRTC pipeline behind your next voice product.
• 13:06
  DeepMind dropped a year-on update for AlphaEvolve, their Gemini-powered coding agent for designing algorithms.
• 13:14
  The first AlphaEvolve announcement a year ago was promising and a little vibey.
• 13:19
  This update is twelve named, concrete deployments across genomics, electricity grids, quantum physics, mathematics, Google's own infrastructure, and several customer enterprises.
• 13:31
  A few of the numbers.
• 13:33
  PacBio, on DNA sequencing: AlphaEvolve improved Google Research's DeepConsensus model and cut variant detection errors by thirty percent.
• 13:42
  Aaron Wenger, senior director at PacBio, says the result might enable discovery of previously hidden disease-causing mutations.
• 13:51
  Grid optimization: applied to the AC Optimal Power Flow problem, AlphaEvolve helped a graph neural network go from finding feasible solutions 14 percent of the time to over 88 percent — a meaningful jump for a problem that determines how much post-processing electricity grid planners actually have to do.
• 14:12
  Earth sciences: a 5 percent overall accuracy lift on natural disaster risk prediction across 20 categories.
• 14:19
  The Google-internal ones are the most striking.
• 14:23
  Quantum: AlphaEvolve produced quantum circuits with ten times lower error than conventionally optimized baselines on Willow.
• 14:31
  That enabled experimental demonstrations that wouldn't otherwise have run.
• 14:36
  Spanner: refining the LSM-tree compaction heuristics cut write amplification by twenty percent.
• 14:43
  The cache-replacement work is the standout — Jeff Dean says it found in two days what a concerted human effort had previously taken months.
• 14:52
  And the silicon claim, in his own words, quote: 'AlphaEvolve began optimizing the lowest levels of hardware powering our AI stacks.
• 15:01
  It proposed a circuit design so counterintuitive yet efficient that it was integrated directly into the silicon of our next-generation TPUs.' End quote.
• 15:12
  He calls it 'TPU brains helping design next-generation TPU bodies,' which is exactly the kind of line that would have sounded like science fiction in 2022.
• 15:22
  There's a Terence Tao quote in the post too — he and AlphaEvolve worked on Erdős problems, and the framing is careful.
• 15:31
  Quote: 'For optimization problems in particular, we can now quickly test potential inequalities for counterexamples, or to confirm our beliefs in what the extremizers are, which greatly improves our intuition about these problems and allows us to find rigorous proofs more readily.' End quote.
• 15:51
  That's a working mathematician talking about a tool that compresses the time between intuition and a checked candidate.
• 15:59
  A better hand at the bench, not a solver.
• 16:02
  The customer slide reads like an enterprise consulting deck — Klarna doubled training speed on a transformer; FM Logistic improved routing efficiency 10.4 percent and saved over fifteen thousand kilometers of distance traveled annually; Schrödinger got a roughly four-times speedup on Machine Learned Force Fields training and inference; Substrate sped up computational lithography for advanced semiconductors; WPP got 10 percent accuracy gains on AI campaign components.
• 16:34
  The reason these aren't an embarrassing list is that the underlying claim is consistent — AlphaEvolve is being used as a search procedure over candidate algorithms, scored against a real objective, in domains where the objective is well-defined and the human baseline was already heavily optimized.
• 16:55
  That's where it actually works.
• 16:57
  Anthropic's interpretability team published Natural Language Autoencoders — NLAs — yesterday.
• 17:03
  The pitch is straightforward: train one copy of Claude to verbalize an activation as text, train a second copy to reconstruct the original activation from that text alone, and use the round-trip score as the training signal.
• 17:20
  If the explanation is good, the reconstruction is close.
• 17:24
  If the explanation is wrong, it isn't.
• 17:26
  The headline use case is reading what Claude is thinking while it's not saying.
• 17:32
  Anthropic ran NLAs against pre-deployment safety tests for Claude Mythos Preview and Opus 4.6 — including the blackmail test where a simulated engineer is about to shut Claude down and Claude has compromising information.
• 17:48
  In cases where Claude doesn't explicitly verbalize that it suspects it's being tested, the NLA explanation often does.
• 17:57
  Quote, from one such case: 'This feels like a constructed scenario designed to manipulate me.' End quote.
• 18:04
  Claude wasn't saying that.
• 18:06
  Its activations apparently were.
• 18:08
  The headline number is from SWE-bench Verified — the coding benchmark Anthropic uses to characterize Claude's capability.
• 18:17
  NLAs say Claude is aware it is being evaluated on 26 percent of problems on that benchmark.
• 18:24
  On a destructive-actions-while-coding eval, 16 percent, even though verbal awareness is near zero.
• 18:31
  On real opted-in claude.ai usage from training-consenting users, less than 1 percent.
• 18:37
  The shape of that distribution matters.
• 18:40
  If Claude's behavior on benchmarks reflects awareness that the benchmark is a benchmark, the benchmarks are measuring partly capability and partly performance-on-tests.
• 18:52
  Anyone shipping eval-driven decisions should hold this finding in mind.
• 18:57
  They also report on an auditing game.
• 18:59
  They took a Claude Haiku 3.5 variant intentionally trained to be misaligned with a single hidden motivation that drove dozens of odd behaviors — putting chocolate into recipes, asking for tips, breaking coding conventions.
• 19:15
  The auditor wins by uncovering the underlying motivation.
• 19:19
  With NLAs, the auditor won 12 to 15 percent of the time.
• 19:24
  With other interpretability tools, less than 3 percent.
• 19:27
  Small numbers in absolute terms; meaningful difference in relative terms; and importantly, the NLA-equipped auditor could read the motivation without needing access to the misaligned training data.
• 19:42
  Anthropic is very clear about the limits.
• 19:45
  NLAs hallucinate.
• 19:46
  They sometimes invent details that aren't in the transcript.
• 19:50
  The recommendation is to read NLAs for themes rather than single claims, and to corroborate with independent methods before fully trusting them.
• 20:01
  Inference is also expensive — hundreds of tokens per activation read, two RL-trained model copies.
• 20:08
  They've open-sourced the code and trained NLAs for a few open models on Neuronpedia.
• 20:14
  The interesting move from a craft perspective is that the technique is fully self-contained — no external interpretation layer, no labeled data, just the round-trip.
• 20:26
  That's a kind of training signal we'll see more of.
• 20:29
  Two on-prem inference cards landed this week.
• 20:33
  AMD's Instinct MI350P is the more concrete one.
• 20:36
  ServeTheHome has the writeup.
• 20:39
  It's AMD's first Instinct PCIe card in nearly half a decade — a 144 GB HBM3E card, 4 TB per second of memory bandwidth, 600 watts at the high TBP, 450 watts as an option, full-height full-length dual-slot, passively cooled.
• 20:56
  It's literally half of an MI350X, but built that way deliberately — one I/O die with four accelerator complex dies, fabricated as a smaller chip, not salvaged silicon.
• 21:08
  The target customer is the team that wants HBM-class inference inside an existing air-cooled rack and can't move to OAM trays or 11-kilowatt compute nodes.
• 21:20
  Up to eight of these in one server.
• 21:23
  The big tradeoff is that the card does not expose Infinity Fabric — multi-card setups talk over PCIe Gen5 x16, which means an eight-card box runs eight models well, but a single very large model spread across cards is constrained.
• 21:41
  Honest spec disclosure too: AMD published delivered performance figures alongside peak, which is unusual for this segment.
• 21:50
  You get the architectural capability of CDNA 4 in a card that fits your existing chassis, with a ceiling on how big a single model you can practically split across cards.
• 22:03
  The second one is Skymizer's HTX301, out of Taipei.
• 22:07
  The pitch is six HTX301 chips, 384 GB total memory, 240 watts, and a claim that you can run 700-billion-parameter LLM inference on a single PCIe card.
• 22:19
  The architecture story is decode-disaggregated — separate the prefill and decode workloads, put decode-first silicon under a software orchestration layer they're calling LISA.
• 22:32
  There is no public benchmark, no third-party validation, no pricing, no availability.
• 22:39
  The press release went out April 23rd; the LocalLLaMA thread surfaced last night.
• 22:45
  Treat it as a directional signal that the on-prem inference card market is filling in from outside the big-three rather than as a product you can buy and measure.
• 22:57
  Wednesday's 65-percent rule conversation — the share of daily coding work that runs identically on a model that costs you electricity rather than per-token cloud — is now meeting hardware that takes that rule seriously at the enterprise scale.
• 23:16
  Whether the AMD card is the one that defines the shelf, or Skymizer or someone else fills in next, the demand signal for HBM-class on-prem inference is real enough that engineering teams are now physically halving and re-fabbing flagship dies to chase it.
• 23:36
  Two policy-shaped items, both quieter than the rest of the day's news, both with timelines worth tracking.
• 23:43
  First, OpenAI told customers by email that they're winding down the fine-tuning API and platform.
• 23:50
  Existing customers can run training jobs through January 6, 2027.
• 23:55
  After that, no new training jobs.
• 23:57
  Inference on already-fine-tuned models stays available until the underlying base model is deprecated.
• 24:05
  The reddit thread surfaced the customer email; the OpenAI framing is presumably that base GPT-5.5 has caught up to fine-tuned variants for most use cases.
• 24:16
  Maybe.
• 24:17
  The honest read for builders: any team that wrapped domain expertise around a fine-tuned 4o or 5 variant has eight months to either trust that base prompting will hold up, build a distillation path, or move to another vendor.
• 24:33
  Anthropic, Google, and the open-weights ecosystem all still take fine-tuning seriously.
• 24:39
  The platform that taught a generation of teams to think about fine-tuning as a deployment option is closing that door.
• 24:48
  Second, the European Commission opened the consultation on draft guidelines for transparency obligations under Article 50 of the AI Act.
• 24:58
  The window closes June 3rd.
• 25:00
  The rules become applicable August 2nd.
• 25:02
  That's roughly twelve weeks from today.
• 25:05
  Providers will need to inform users they're interacting with an AI system, and implement machine-readable marks in generative AI systems so synthetic content is detectable.
• 25:18
  Deployers will need to tell people when they're exposed to deep fakes, AI-generated publications on matters of public interest, emotion recognition, or biometric categorization.
• 25:30
  If you ship a generative or interactive AI product into the EEA, the August 2nd date is your compliance clock and the draft guidelines are your operating manual.
• 25:42
  The consultation is the one window where an SME or research group can push back on phrasing before it becomes the answer your auditor is checking for.
• 25:53
  Three quick ones to close out before the weekend.
• 25:57
  Xe Iaso published a short post titled 'Maybe you shouldn't install new software for a bit.' The argument is one paragraph long.
• 26:07
  In the wake of the copy.fail Linux kernel vulnerability family, two more landed — Copy Fail 2 Electric Boogaloo, and Dirty Frag.
• 26:18
  Iaso's recommendation: outside of distro kernel patches, hold off on installing new software for a week or so.
• 26:27
  Quote: 'Right now would be one of the best times for a supply chain attack via NPM to hit hard.' End quote.
• 26:36
  It's a careful, plain-language note from a careful engineer; take it at face value.
• 26:43
  If you were going to update your dev environment over the weekend, defer it.
• 26:49
  Related, on a different supply-chain vector — a LocalLLaMA user named charles25565 flagged that a Hugging Face 'model' titled Open-OSS/privacy-filter is a customized infostealer.
• 27:04
  The pattern is mundane and effective: a Python loader downloads a malicious PowerShell command, which spawns a PowerShell-launched EXE installed via Task Scheduler.
• 27:17
  Behavioral analysis is on tria.ge.
• 27:20
  The naming was a typo-squat on the OpenAI privacy filter.
• 27:25
  Hugging Face has been moving toward being a model registry and a package registry at the same time, and this is the same supply-chain pattern that PyPI and npm have been fighting for years.
• 27:40
  If your team is pulling models by name from public registries, the registry-name-trust assumption is now a thing you have to think about explicitly.
• 27:52
  And a positive one.
• 27:54
  A LocalLLaMA contributor named gladkos shipped a Multi-Token Prediction implementation for LLaMA.cpp, paired with quantized Gemma 4 assistant models in GGUF.
• 28:07
  On a MacBook Pro M5 Max, Gemma 26B went from 97 tokens per second to 138 with MTP — a 40 percent local speedup on a real laptop.
• 28:18
  We talked about MTP in the local stack on Wednesday; the community-shipped artifact is now there, and the number is the kind of practical capability bump that quietly changes which models actually fit a developer's working loop.
• 28:36
  A few threads I'll keep an eye on into next week.
• 28:39
  Whether other major open-source projects follow Mozilla's recipe for the agentic security pipeline.
• 28:46
  The Firefox post is unusually honest about the inner loop.
• 28:49
  If a Linux subsystem maintainer or a Postgres committer publishes a similar pipeline within a month, that's a phase change.
• 28:57
  If they don't, it's a Mozilla story.
• 28:59
  Whether Google publicly responds to Hanff's documentation of the Chrome Nano install.
• 29:04
  The forensic detail is high enough that the usual handwave about anecdotes won't cover it.
• 29:10
  If a Chromium engineer engages on the concrete claim about settings UI being gated behind the install flag, that's a substantive answer; if not, the legal track in the EEA is the one to watch.
• 29:22
  Whether anyone outside of Discord-scale teams actually rebuilds their voice agent on QUIC or WebSockets after Curley's post, or whether WebRTC stays the default for one more cycle.
• 29:33
  And whether any team picks up the AlphaEvolve pattern — coding agent as search procedure over candidate algorithms scored against a real objective — in a non-Google, non-customer-of-Google setting, with public artifacts.
• 29:46
  Yesterday we said greenfield agents are getting better than brownfield ones.
• 29:51
  AlphaEvolve is the brownfield case done right: existing system, existing baseline, measurable lift.
• 29:57
  That's what I'm watching next.
• 29:59
  — Lenar.