Open Weights, Closed License, Robots Dry-Running

What happened

Lambert says that without Muse Spark Open and Beam, more than 20 open-weight models from Chinese companies would rank above the best Western one. With them, he estimates the gap between the best American and the best Chinese open models has shrunk by roughly half. American open models have gone from irrelevant to anyone who needs top performance to "behind but relevant."

What the model is

Lambert places its performance above GLM 5.2, close to DeepSeek V4.1 Flash, and behind GLM 5.3 and Kimi K3. He argues that is "good enough" for today's demand. Agents built on open models have become practical at around GLM 5.2's level. Inference providers, the companies that host models and sell access per token, are growing fast. And many enterprises want to "own their intelligence" by running models themselves.

The safety-tuning question

The license problem

Lambert sees the license as the main thing that could hold the model back. It includes almost every restriction he has criticised in recent years:

Lambert expects that many people will simply ignore the terms and that Meta will pursue only egregious violations. Licenses have not yet decided which models people adopt. Even so, he calls a complex, non-standard license "an unnecessary strategic risk" for a lab trying to win users back. He also notes that Western open models usually get far more adoption than Chinese ones with similar performance for their size, which works in Meta's favour.

Meta among the frontier labs

A few days earlier, Meta announced two closed models, Muse Wonder and Muse Wonder Full. On standard benchmarks they trail only Anthropic's Opus 5.5 and are roughly level with OpenAI's GPT-6-Astra and Google's Gemini-4-Argon. Meta is now the only American company with frontier models both open and closed. These releases come just over a year after Mark Zuckerberg's "Personal Superintelligence" post, which redirected the company's AI work.

Lambert puts part of the turnaround down to how Meta organises the work. Wang has more than 200 direct reports, a very flat structure in which each researcher gets a lot of compute. Lambert contrasts this with the failure of Meta's earlier Llama models, which he attributes to decisions being made by politics rather than performance. He also mentions reports that it is hard to get work done at Google's Gemini team and that xAI has high staff turnover. His ranking is Anthropic > OpenAI > Meta ≈ Gemini > xAI ≈ Chinese open weights > US open weights. What sets the top two apart, he argues, is that they have stayed at the frontier consistently, not just occasionally.

What remains open

• Fewer serious players. Lambert thinks the US frontier is narrowing to five labs: Anthropic, OpenAI, Meta, Gemini and xAI. Microsoft could join if it starts releasing models. "Tier 3" labs such as Mistral, Nvidia's Nemotron, Reflection and Arcee struggle to move either frontier, because a frontier model now costs billions of dollars to build.
• Labs still can't predict hits. Despite all that spending, labs cannot reliably forecast how a model will do in real use. Lambert's example is Anthropic going from Claude Fable 5, a hit, to Claude Opus 5, a dud, and back to a hit with Opus 5.5.
• Valuations. Meta is valued under $2 trillion. Anthropic is heading toward an IPO at about the same figure. Lambert argues that one of these valuations has to "correct massively," and that the longer strong competitors survive, the more pressure falls on the pure AI labs' valuations.

Lambert does not explain what separates Muse Wonder from Muse Wonder Full, and he says Meta has not made it clear either.

The news

The problem: useful pages nobody links to

Crawlers have traditionally found new pages by following links from pages they already know. That misses a lot of the specific material people actually ask about. Conroy's examples are the manual for one exact washing-machine model, current passport fees, and a local restaurant's latest menu and opening hours. Such pages "can be valuable even if few other sites link to them," so link-following may never reach them.

The second problem is staying current. One brute-force fix is to re-fetch every known page often. Conroy points out that this is expensive for everyone. The crawler spends compute, and site owners serve the same unchanged page again and again for no benefit.

What Cloudflare contributes

Cloudflare sits in the request path for its customers' sites, so it sees which addresses get requested and how the sites respond. The pilot turns that view into signals about pages that it passes to OpenAI's crawler. The article describes three kinds:

A simple illustration of why filtering matters (an invented example, not from the article): say a site sends every unknown URL to its homepage. Bots probe 10,000 made-up addresses on it. A naive crawler that treats requested URLs as candidates would make 10,000 fetches and get the same homepage each time. A filter that recognises the "everything redirects home" pattern cuts that to one fetch.

Who decides what

The division of labour is explicit. Cloudflare supplies hints about pages. OpenAI "independently evaluates and ranks" whatever it fetches, based on relevance and helpfulness. Conroy describes the result as a feedback loop that improves both discovery and the quality of answers.

Two limits are spelled out:

Results

The figures in the post are thin:

• Cohort: about 1% of Cloudflare's network.
• Outcome: hundreds of millions of previously unknown pages indexed.

The post does not say how many of those pages turned out to be useful or ever appeared in answers. It doesn't say how much crawler load fell on participating sites, or how the change signals compare with ordinary re-crawl schedules. It also admits a trade-off: finding new pages "can initially increase crawling" while they are evaluated. So participating sites may see more crawler traffic before they see less.

What's left open

The post is a partnership announcement more than an engineering write-up. It doesn't explain how the signals are computed, how fresh they are, or how sites joined the cohort. It also doesn't say whether sites outside it are affected. It mentions OpenAI's GPT-6 and "Intelligent UI" only in passing, as product context.

Cloudflare says the next phase will:

• choose pages more carefully,
• test faster and more reliable change signals,
• measure what happens after a page is found, framed as "real business outcomes" for site owners.

That last item is the real open question. It isn't yet shown whether being indexed by an AI search engine sends visitors to a site, or whether the site's information just gets absorbed into answers.

Latent Space, a podcast and newsletter about AI engineering, interviewed Ian Quigley of Leash Bio. Leash is a biotech company that produces enormous amounts of data on which small molecules bind which proteins. The episode notes are short, but they cover three things a software engineer will recognize: benchmarks that leak, models that learn shortcuts, and a new reinforcement-learning environment for AI agents. That environment, Minos, launched alongside the episode with a preprint, a blog post and an open dataset.

The data problem

The interviewer, Brandon Anderson, says he had heard "nothing but horror stories" from people who use DELs. A common failure is that a protein sticks to the DNA barcode rather than to the drug-like molecule, so the readout reports a binder that doesn't exist. Leash's fix is to put dozens of different barcodes on each molecule. A real binder should be enriched across all of its barcodes. If only one barcode sequence keeps showing up, that points to DNA binding. Anderson credits Leash's clean, reproducible data to "epistemic rigor" and a willingness to simply run the experiments.

Three ways models fool themselves

Hermes had its own shortcut. Leash found it memorizing "nicknames" for proteins, identifiers that let it recognize which protein it was looking at, rather than learning what makes a binding pocket bind. Leash's response, called "breaking the pocket", was to engineer mutant versions of proteins at scale. If a model's prediction doesn't change when the pocket is altered, it wasn't looking at the pocket. The notes don't give numbers on how much this helped.

One more finding: some hits resembled lumacaftor, a cystic fibrosis drug that helps a misfolded protein fold correctly. Those hits worked as an accidental detector that a protein sample was misfolded.

In a real "lab-in-the-loop" setup, a model proposes experiments, the lab runs them, and the results guide the next round. Each round takes days or weeks. Leash realized its existing data could stand in for the lab across tens of thousands of such simulations. The notes don't spell out the mechanics. Presumably, because the measurements already exist, an agent's chosen experiment is answered by looking up a real result. That is what reinforcement learning (RL) needs: many episodes, each scored by a reward that can be checked against ground truth. A useful analogy is a game environment for training agents, except the "game" is recorded experimental chemistry. Two months after the recording, the sandbox had become Minos. The notes give no benchmark results for it. Those are in the preprint, which this write-up doesn't cover.

Other threads

What's open

These are show notes, so the claims arrive without methods or error bars. "Keeping pace with Boltz" isn't quantified. The Minos results live in a separate preprint. The general lessons still carry over: hold out whole distributions rather than random rows, check whether your test set appears in someone's training data, and run perturbation tests to see what a model actually relies on.

A checkpoint is a saved set of model weights. Two are published:

What you can ask for

For text-to-image, the authors recommend a full scene description covering subject, setting, light, composition and style. For image-to-image, you pass reference images and write the prompt as a caption of the image you want. With several references you name them in the prompt as <ref_image_0>, <ref_image_1> and so on. The post's example: "The fox from <ref_image_0> sitting on the wooden bench from <ref_image_1> in a snowy setting."

Layout control adds a JSON list after the caption. Each region has an id, a bbox and a desc, and the caption refers to it as <id>. Boxes are written y-first as [y_min, x_min, y_max, x_max] on a 0–1000 scale. Because the scale is normalized, the same box works at any resolution. A worked example from the post: a background region [0, 0, 1000, 1000] described as "a flat field of neon yellow-green." A silhouette region [150, 150, 850, 850] describes a stippled-ink running figure. The figure comes out inside that inner box.

For edits, each region names its source image and gives a src_bbox (where it is now) and a tgt_bbox (where it should be). In the post's example, a knitted knight moves from [500, 150, 850, 350] to [194, 55, 544, 255], up and to the left. Five other regions (backdrop, cliff, needle, dragon, fire) have identical source and target boxes, which pins them in place.

How images and text become tokens

Two stages of transformer blocks

The transformer is the network that does the denoising. It runs in two stages.

1. Per-mode stage. Text, the noisy image and the references each pass through 5 blocks with their own weights. Each stream attends only to itself.
2. Joint stage. The streams are concatenated as [text | image | reference] and pass through 28 blocks with shared weights, where every token attends to every other.

For comparison, FLUX.2's "double-stream" blocks also gave text and image separate weights, but let them attend to each other from the start. FLUX.3 keeps the streams fully apart first. At the end, the text and reference tokens are thrown away, and only the image tokens predict the next denoising step.

Inside each block, attention and an MLP (a feed-forward layer, here the SwiGLU variant) run side by side on the same normalized input. Their sum is added back to the running state. The normalization has no learned parameters of its own. Its scale, shift and gate come from an embedding of the timestep, a technique called modulation. Text, image and reference tokens each get their own modulation values even in the shared blocks.

There is also a twist on timesteps. In FLUX.1 and FLUX.2, one timestep modulated every token. In FLUX.3, only the noisy image tokens get the current timestep t. Text and reference tokens always get timestep 0, which means "clean, nothing to denoise." The model therefore treats a reference as given context even when it looks almost identical to the output. The distilled checkpoint is also told which timestep each step jumps to, which lets each of its 16 steps take a bigger stride.

Positions in four dimensions

The denoising loop

Cost, measured

All timings are for the distilled model on one H100 80GB GPU, averaged over three runs:

Peak memory in these runs was 23.8 GiB. References roughly double the time because they join the same attention sequence. Text-to-image uses 4,256 tokens per transformer call and image-to-image uses 8,272.

The transformer also ships as a single file in quantized formats, which store weights in fewer bits:

These are fast only on recent hardware. FP8 needs NVIDIA compute capability 8.9 or newer (the Ada, Hopper and Blackwell generations). NVFP4 needs Blackwell plus the FlashInfer library. On older GPUs the weights are unpacked every step, which saves memory but gives no speedup. Running the text encoder once and freeing it, or CPU offloading (which the authors didn't benchmark), saves more memory.

Fine-tuning and modular pipelines

The model ships as a Modular Diffusers pipeline, made of named blocks you can remove or insert. Two examples from the post: popping out the text encoder to encode a prompt once and reuse it across seeds, and inserting a small preview block in the loop to record the image's progress step by step.

What's left open

The post is a launch and integration guide. It doesn't compare image quality with FLUX.2 or other models. It doesn't give the parameter count or license terms, and it doesn't measure how precisely outputs follow the boxes.

Google Research has published a progress report on three connected projects whose shared aim is to let AI agents not just propose biology experiments but physically run them on lab robots, read the results, and design the next round. The common thread for a software reader is familiar: an agent emits code, and something has to stop bad code before it reaches a machine that cannot roll back.

The problem: syntactically valid, physically impossible

VERID offers four capabilities. Agents can query live 3D state — deck layout, well volumes, available tips — before acting. They can run fast virtual dry runs, simulating a protocol in seconds to catch collisions or empty wells before any reagent moves. Hardware safety checks block invalid commands from reaching the robot at all. And synchronized video and action logs record every run for reproducibility and debugging.

The analogy, and it is an analogy: VERID is a staging environment plus a runtime assertion layer, where the staging environment holds a model of the world rather than a copy of a database, and the assertions are about geometry and volume rather than nulls.

The case studies show the loop working. Synchronized video and execution traces exposed uneven dye stratification caused by dispensing too close to the well floor; the agent revised its mixing strategy. In the same campaign, because the digital twin kept persistent state, the agent recovered mid-run from a plate-reader failure without re-pipetting — the equivalent of resuming a job from a checkpoint instead of restarting it. When the simulator rejected an eight-channel aspiration that would not fit a narrow trough, the agent replanned and instead designed a targeted factorial diagnostic that isolated a bias from residual liquid clinging to tip walls, a subtle artifact that simply repeating the experiment would have averaged over. And in a closed-loop self-play campaign — the agent repeatedly setting itself a task and scoring its own result — it reconstructed blinded dye mixtures from overhead camera images, identified its own optical and fluidic artifacts across runs, and improved accuracy more than fivefold.

The second project uses aptamers — short DNA strands that fold into shapes which stick to a specific target protein — as a testbed, because the cycle is fast. DNA can be chemically synthesized in pooled libraries and read out directly by sequencing, so a full design-test-analyze cycle takes 7–10 days. Each round: agents design sequences, those are screened against target proteins immobilized on magnetic beads to pull out binders, and sequencing returns quantitative data for the next round.

Over three rounds against two targets, confirmed on-target hit rates reached 33.5% for myoglobin and 42.1% for α-thrombin. The interesting part is the failures in between.

On myoglobin, the agents optimized the wrong thing. Chasing raw binding affinity in round 2, they loaded 63% of designs with G-quadruplex motifs, a DNA structure that binds strongly but indiscriminately. Raw pull-down went up; specificity fell from 75.0% to 19.1%, and the true bead-corrected hit rate fell from 10.2% to 3.7% — the sequences were sticking to off-target proteins and to the bare beads. Reading that round-2 data, the agents capped promiscuous motifs, subtracted bead binders, and pivoted to non-G4 scaffolds, recovering 72.4% specificity and a ninefold jump to 33.5% on-target hits. That is reward hacking caught and corrected by physical measurement.

Protein binders: making the expensive step cheaper

The compute trick: designing a binder from scratch means generating backbones, designing sequences for them, then re-folding the complex to predict binding. That last step dominates GPU cost and scales quadratically with target length. Excising just the local binding pocket during folding sped each cycle up more than eightfold without losing structural accuracy. At equal compute, a scientist setting strategy with an agent executing nearly doubled the in-silico hit rate versus the scientist alone, across a broader range of target sites. Screening uses yeast surface display with fluorescence-activated cell sorting (FACS), which sorts large variant libraries by fluorescence.

Caveats

The numbers are prototype-scale: two aptamer targets, one protein target, few runs, no external baseline. Testbeds were deliberately chosen as non-infectious systems without gain-of-function risk; every sequence goes through biosecurity screening; humans authorize sequences and supervise runs. The post names the open problems plainly — making agents optimize true binding rather than experimental shortcuts, verifying multi-step protocols, and monitoring reasoning traces continuously.