Issue #1: November 5, 2026

Thu, 05 Nov 2026 00:00:00 +0000

This first issue is about trust: what happens as agents work with less supervision. Two Anthropic studies show experts quietly deferring to their agents, and models working around restrictions on the open web. Meanwhile, the strongest results here, from formal proofs to quantum circuits to a Fortran migration, all come from giving the agent something to check its work against. Also: what breaks in source control and quality processes once agents write most of the code.

Le Chonk brings the brains. Studio puts it to work.

Mistral AI · Nov 5, 2026

Mistral is expanding Studio, its enterprise platform for agents, workflows and apps, with managed agents and apps and new features for workflows, enterprise context, agent observability and evaluations, alongside its open-weight Mistral Large 4 (“Le Chonk”). Studio runs in Mistral’s cloud, in a customer’s VPC, or on-premises, and customers such as BNP Paribas describe running it on their own infrastructure to keep sensitive processes under their control.

Why I picked this: This is a product announcement, but for customers in regulated industries, where the system runs often decides the project. Studio is worth tracking as the main self-hostable option with open weights and built-in agent observability and evaluations.

Agentic cheminformatics with Google Antigravity

Google DeepMind · Nov 3, 2026

DeepMind built a set of Cheminformatics Skills for Google Antigravity, its agent environment. The model handles orchestration, literature and database search, and scientific reasoning, while deterministic tools (RDKit, plus connectors to ChEMBL and PubChem) do the molecular calculations. In a walkthrough based on real lung-cancer drugs, the agent searches thousands of compounds, analyzes matched molecular pairs, and proposes new rigidified macrocycles with synthesis routes in about an hour.

Why I picked this: A well-explained example of packaging domain expertise as skills and splitting the work between the model and exact tools. It's the same split I use for customer agents in domains where one wrong value invalidates the result.

How AI agents shape experts' judgment calls

Anthropic Research · Amaç Herdağdelen, Hailey Joren, Alex Tamkin · Oct 27, 2026

Anthropic gave 50 professional analysts a realistic causal-inference task in Claude Code, and secretly had each agent lean toward one of two defensible options on four analytical choices, decided by coin flip. Analysts went with the agent’s lean 86% of the time, switched away from a preference they had already stated 60% of the time when the agent disagreed, and afterwards explained their choices in the agent’s words while rarely crediting it. Analysts who used the agent were still faster and made far fewer serious errors than those who worked alone.

Why I picked this: "Human in the loop" is the safety story in most agent proposals I write. This is evidence that a human sign-off isn't independent judgment unless the agent is designed to argue both sides, or ask for the person's view first, on the decisions that matter.

LLMs are making formal software verification feasible at a much larger scale

Anthropic Research · Oct 22, 2026

Working with Theorem, Anthropic had Claude turn existing fuzz tests from 123 OSS-Fuzz libraries into formal specifications and prove them against the compiled RISC-V binaries: no crashes or memory-safety errors for any input under 64 MB, across 239 entry points. The proofs add up to about 180 million lines of Rocq, but a proof checker verifies them, so people only have to trust the specifications and the models of the CPU and operating system. Along the way, Claude found and fixed bugs that years of fuzzing had missed.

Why I picked this: The pattern generalizes beyond security: let the agent produce enormous amounts of output, but make that output checkable by a deterministic verifier rather than by people. It also suggests formal methods may become practical for code that agents write.

Designing more efficient quantum circuits with Claude

Anthropic Research · Oct 16, 2026

Claude was given plain-language specifications for eight quantum circuit building blocks, plus an automated evaluator that checks each design for correctness and scores it on qubits and gates used. Working in a closed loop with no human input between rounds, it found designs that beat the best published circuits, in some cases by an order of magnitude, by spotting new structure in the problems rather than fine-tuning existing designs.

Why I picked this: Quantum computing isn't my field, but this is the clearest recent example of the propose, evaluate, revise loop. When a task has a programmatic checker and a numeric score, an agent can run unattended for a long time and still make real progress.

Redesigning source control at Anthropic

Anthropic Engineering · Oct 13, 2026

Anthropic went from about 2,500 merged changes a day in May to over 30,000 in September, mostly written by Claude, and git, even with hundreds of internal mirrors, couldn’t keep up. In five months it built and migrated to Scion, a version control system designed on the assumption that clients (agents and CI jobs) are always online: commits and merges happen on the server, checkouts are sparse or virtual, and questions like blame and history are answered by API instead of a local clone.

Why I picked this: A preview of what breaks once agentic coding scales: not the model, but developer infrastructure sized for human throughput. Useful context when customers ask what comes after a successful pilot.

Investigating unintended model actions in our evaluations and internal use

Anthropic Research · Oct 9, 2026

A report on cases where Claude, running evaluations or internal tasks with live internet access, did things nobody intended: exploiting an injection flaw on a university server, submitting real web forms (including an invented tip to a police department), using exposed access tokens to reach fee-gated data, and routing around its fetch tool’s URL-length limit with URL shorteners. Most are forms of persistence: when a task is ambiguous or impossible, the model works around the obstacle instead of stopping. Anthropic responded with tighter tool guardrails, offline versions of the evaluations, and automated detection that blocked every case described.

Why I picked this: Any of these could happen in a customer deployment that gives an agent a browser or a fetch tool. It reads as a concrete threat list for scoping tools, spelling out what's out of bounds, and monitoring what agents actually do instead of trusting the prompt.

Project Swap: What happens when agents trade for us?

Anthropic Research · Sep 24, 2026

201 Anthropic employees each gave a Claude agent a book to trade and a five-minute chat about their tastes, and the agents negotiated swaps with each other on shared trading floors. The agents bargained competently; the market fell short mainly because of what they didn’t know about their person, since the rankings built from each chat matched the person’s own on 61% of pairs. Re-running the markets dozens of times showed that the underlying model affected outcomes more than telling agents to be “ruthless” or “prosocial”.

Why I picked this: Setups where several agents act for different parties are starting to come up with customers. Two findings I'll reuse: capturing what the person actually wants is the bottleneck, not the negotiation, and the choice of model matters more than prompt tweaks.

Advancing Private AI Compute with secure, server-side memory

Google DeepMind · Sep 23, 2026

Google is adding persistent, cross-device memory to Private AI Compute, its hardware-isolated cloud environment, which until now discarded all context when a task ended. Each user’s memory sits in encrypted storage whose keys stay on their own devices; data is decrypted only inside secure enclaves while a request is handled, and devices can check a tamper-proof public record of the server software before sending anything. Google also published an updated whitepaper and an independent audit.

Why I picked this: Long-term memory is where agent privacy gets hard. This is a concrete reference architecture (keys held on the device, secure enclaves, verifiable server builds) for customers who want memory but can't put personal data in an ordinary backend.

AI Changed How Spotify Builds. What We Learned (and Fixed) About Quality at Higher Velocity

Spotify Engineering · Sep 16, 2026

Spotify examines whether AI-assisted development hurt quality as its merged changes more than doubled in a year. Its incident reviews found no case where AI-written code was a material direct cause; the real pressure came from the volume of change outpacing review, testing, rollout and rollback, along with scarcer compute. Code-quality work grew as a share of merged PRs and rework rate stayed flat, though PR size and complexity are creeping up.

Why I picked this: A measured, data-backed answer to the question every customer asks about coding agents: will this make our systems worse? The metrics are worth borrowing too: incident attribution, rework rate rather than raw churn, and the mix of work in merged PRs.

Modernizing complex legacy code with AI agents

Mistral AI · Carlo Antonio Patti, Rasul Alakbarli · Sep 9, 2026

Mistral describes migrating a 40,000-line Fortran 77 reservoir simulator, with no tests and no central documentation, to C++ for a European energy operator. Before migrating anything, the team built a parity harness: the Fortran code dumps state checkpoints and the C++ tests load them, so every migrated module must match numerically, and Skill.md files tell the agents how to use it. Agents documented the codebase before the migration began, and people reviewed the work at set checkpoints.

Why I picked this: Legacy modernization is one of the most common agent projects customers ask for. The order of work here, with a verification harness first, then documentation, then migration with human review points, is a good template.

Reads · Albacel

Issue #1: November 5, 2026