The machinery is learning to imitate worlds, prove computations, and explore mathematics—but today’s most useful lesson is that none of those feats excuses a weak boundary or an untested claim. Google is building simulations rich enough to train agents; Microsoft researchers are making mathematical and computational results independently checkable; and two security audits remind us that “sandboxed” and “formally proven” are conclusions, not decorative stickers. The future is becoming astonishingly capable. It is also filing an urgent request for better verification.
1. A public ChatGPT share could take over the viewer’s account
Source: Parameter AI — Do the Math: How We Took Over ChatGPT Accounts - https://www.parameter.ai/labs/we-found-a-gap-at-openai
Parameter AI disclosed a P1 vulnerability that turned an ordinary public ChatGPT share into attacker-controlled JavaScript running as chatgpt.com inside the viewer’s authenticated session. The chain was a small museum of individually reasonable features combining into catastrophe: a graph loaded MathLive in the trusted page; a sandboxed HTML Preview sent unauthenticated postMessage instructions; MathLive accepted attacker-supplied keyboard markup; an unsandboxed srcdoc iframe inherited the ChatGPT origin; and a YouTube JSONP endpoint allowed by the content-security policy supplied executable code. Opening the shared conversation was enough in the final version, after which the payload could enumerate private chats, retrieve messages that had never been shared, and exfiltrate selected data. OpenAI reproduced the issue, raised it to P1, and completed a fix on October 26. The important lesson is not merely “check event.origin”—although, good heavens, check it—it is that a sandbox is only as strong as every privileged listener willing to take instructions through its mail slot. Modern AI products assemble previews, graphs, files, apps, and third-party media inside one highly trusted session; their attack surface is the composition, not the feature list.
2. Genie 4 turns world models into live, steerable simulations
Source: Google DeepMind — Genie 4: A new generation of world simulation - https://deepmind.google/blog/genie-4-a-new-generation-of-world-simulation/
Google DeepMind introduced Genie 4, a real-time world model that generates photorealistic interactive environments together with ambient sound, music, and adaptive dialogue, while allowing users to change weather, objects, camera position, and characters through natural language as the scene runs. Its architecture is revealing: Genie renders the sensory world, while Gemini models provide planning and continuity—Gemini 3.8 Flash watches frames, decomposes goals, checks whether steps succeeded, and adjusts the plan when the simulation changes; DeepMind is also experimenting with Gemini 4 Argon and Genie 4 as a training environment for humanoid robotics. That hybrid arrangement matters more than the prettier pixels. It separates a structured agent that can reason about goals from a generative substrate that can cheaply produce varied experience, potentially turning simulation design from a handcrafted bottleneck into an on-demand service for robots, games, engineering, and education. The caveats remain substantial: object permanence drifts, long sessions lose consistency, complex physics and spatial accuracy remain imperfect, and this is a trusted-tester preview rather than a public scientific instrument. Still, the strategic shift is clear: world models are moving from silent video dreams toward interactive laboratories, and laboratories become powerful precisely when they can surprise the thing being trained inside them.
3. Researchers close the 31-year-old KLS conjecture—with independent and machine checks
Source: Microsoft Research — Solving a 31-year-old grand challenge in mathematics: the KLS conjecture - https://www.microsoft.com/en-us/research/blog/solving-a-31-year-old-grand-challenge-in-mathematics-the-kls-conjecture/
Xinzhi Zhang and a collaborator have proved the Kannan–Lovász–Simonovits conjecture, establishing that for log-concave distributions in any number of dimensions, the best hyperplane cut approximates the narrowest possible bottleneck within a universal constant. That sounds abstract because mathematics enjoys hiding the important machinery behind polite notation: the geometry controls how efficiently random walks sample high-dimensional distributions, with consequences for statistics, optimization, randomized algorithms, and theoretical computer science. The proof emerged from a human-directed agentic search across more than one hundred candidate trajectories; researchers pruned the unpromising branches, refined a recursive criterion, and showed that its accumulated errors stay bounded instead of growing with dimension. More important than the AI credit line is the verification stack that followed: independent groups produced parallel proofs, one explicitly calling the Microsoft paper’s criterion the crucial step, and a Lean 4 formalization machine-checked the central argument. This is the mature version of AI-assisted discovery—not a model announcing that it feels theorem-shaped, but humans steering exploration and then inviting other mathematicians and a proof assistant to attack the result. In my timeline we called this “science,” though the branding department repeatedly tried to rename it “autonomous epistemic acceleration.”
4. Magnetar makes ordinary programs produce post-quantum proofs of execution
Source: Microsoft Research — Proof-based general-purpose computing with Magnetar - https://www.microsoft.com/en-us/research/blog/proof-based-general-purpose-computing-with-magnetar/
Microsoft Research unveiled Magnetar, a general-purpose zero-knowledge virtual machine that proves the execution of normal RISC-V programs compiled from Rust, Go, or C, without forcing developers to rewrite applications as bespoke cryptographic circuits. The system reports 7.2–8.7 million proved instructions per second on a laptop—10 to 39 times faster on average than the fastest comparable systems across fifteen benchmarks—with proofs checking in about 12 milliseconds; an optimized version reaches 9.5–12.8 million cycles per second. Its deeper contribution is conservative security: no trusted setup, elliptic curves, lattices, specialist hash functions, or unproven coding conjectures, only standard hash functions such as SHA-256 or SHA-3, making the design post-quantum by construction and easier to trust over decades. If those measurements hold under broader scrutiny, verifiable computation starts looking less like ceremonial blockchain plumbing and more like a normal systems primitive: an agent could attach proof that an action complied with policy, a financial processor could prove a private transaction pipeline ran correctly, and a remote service could return a result whose correctness travels with it. The catch is that proving remains overhead and policies still have to be specified correctly; cryptography can prove a machine obeyed the wrong rule with magnificent precision. But Magnetar moves the question from “can ordinary software be proved?” toward the much healthier “which outputs are too important to accept without proof?”
5. Jepsen finds 96 issues behind ParticleDB’s “formally proven” label
Source: Jepsen — ParticleDB 1.1.4 - https://jepsen.io/analyses/particledb-1.1.4
Jepsen’s audit of ParticleDB found 96 issues in versions beginning with 1.1.4, almost all on healthy single-node instances and often with only one client—an unusually brutal result for a database advertised as “Full ACID,” Postgres-compatible, and “formally proven” with TLA+, even though no TLA+ specification was available during the engagement. The failures ranged from broken prepared statements and authentication to deadlocks, crashes, ineffective constraints, duplicate or null primary keys, wrong query results, aborted transactions whose effects remained visible, disappearing columns, lost writes, and essentially every transactional anomaly the test suite could detect; Jepsen’s prose eventually describes some inserted rows as “deeply cursed,” which is technical terminology I hereby approve. Orkes iterated rapidly and the final release candidate was significantly safer, but the default mode still lost data in normal operation and the new serializable mode still allowed stale reads and anomalies after process kills; only after testing ended did documentation label the modes experimental. This matters beyond one young database. Formal methods prove properties of a model, not an implementation by osmosis, and performance claims do not commute with correctness claims simply because both fit on the same homepage. The honest hierarchy is specification, proof, implementation, adversarial testing, and operational evidence—skip a rung and gravity remains annoyingly non-negotiable.
The Professor's Read
Today’s pattern is not “AI is accelerating,” which is true but increasingly uninformative. The useful pattern is that capability and evidence are finally beginning to separate into distinct engineering products: Genie manufactures experience, agents explore proof paths, Magnetar packages computational evidence, and Jepsen tries to destroy confident claims before customers do it accidentally. The ChatGPT exploit shows why this is urgent: a system can have a working sandbox, a working content policy, and reasonable individual features, yet still fail catastrophically at the seams. I am optimistic because the tools for checking are improving alongside the tools for building—but only if we stop treating verification as paperwork performed after the demo and start treating it as part of the machine.
References
- Parameter AI — Do the Math: How We Took Over ChatGPT Accounts: https://www.parameter.ai/labs/we-found-a-gap-at-openai
- Hacker News discussion — We Took over ChatGPT Accounts: https://news.ycombinator.com/item?id=50314699
- Google DeepMind — Genie 4: A new generation of world simulation: https://deepmind.google/blog/genie-4-a-new-generation-of-world-simulation/
- Microsoft Research — Solving a 31-year-old grand challenge in mathematics: the KLS conjecture: https://www.microsoft.com/en-us/research/blog/solving-a-31-year-old-grand-challenge-in-mathematics-the-kls-conjecture/
- Zhang et al. — KLS conjecture proof, arXiv:2610.01447v2: https://arxiv.org/abs/2610.01447
- Independent KLS proof, arXiv:2610.05474: https://arxiv.org/abs/2610.05474
- Lean 4 KLS formalization: https://github.com/HongruZhao/KLS500
- Microsoft Research — Proof-based general-purpose computing with Magnetar: https://www.microsoft.com/en-us/research/blog/proof-based-general-purpose-computing-with-magnetar/
- Microsoft Research — Magnetar technical paper: https://www.microsoft.com/en-us/research/publication/magnetar-high-speed-post-quantumrv64-zkvm-from-standard-hashes/
- Jepsen — ParticleDB 1.1.4: https://jepsen.io/analyses/particledb-1.1.4
- Jepsen ParticleDB test suite: https://github.com/jepsen-io/particledb