Structural Reasoning Takes 67 SOTAs, Async RL Ships in GLM-5.2

Featured

01 Reasoning Along Physical Constraints, Not Regressing To A Number

Native structural reasoning is the core of SciReasoner. Instead of compressing a protein, small molecule, or inorganic crystal into one embedding and regressing an answer, it discretizes coordinates, topology, and periodic connectivity into a unified "structure vocabulary." Every structure token becomes a piece of evidence the model can cite mid-reasoning — stepping through stereochemistry, bonding, symmetry, and energetics, the constraints that actually govern the system. That targets the old tension in AI for science: models that predict well can't say why, and models that explain can't compute.

The numbers look solid. Gene ontology annotation for low-homology proteins climbs from 0.42 to 0.55 F_max. Single-step retrosynthesis accuracy goes from 0.63 to 0.72, with fragment-level bond-breaking and precursor traces to back it up. Across 86 benchmarks, 67 land at SOTA.

The double-blind expert evaluation matters most. In 98% of cases, experts judged its reasoning traces as no worse than — and sometimes better than — a frontier model. That says more about "explainable" than any bare accuracy number. The abstract only shows top-line metrics, so how far the interpretability really goes and how the expert panel was sampled need the full paper. For teams working on AI plus science, treating structure as an inspectable reasoning substrate is a direction worth tracking.

Key takeaways: - Discretizing structure into citable tokens, rather than squashing it into an embedding, is what lets prediction and explanation live on one reasoning chain. - The 98% double-blind expert approval of reasoning traces is stronger evidence of real interpretability than any accuracy figure. - Teams in AI plus science should watch the "native structural reasoning" line, but the depth of the interpretability still needs the full paper and evaluation details.

Source: Accurate, Interdisciplinary and Transparent Structure-property Understanding with Deep Native Structural Reasoning

02 You're Picking Who Won't Steer You Into A Ditch

Most coding-agent benchmarks compress a run into one bit — passed or failed. But people who actually use agents live in the whole trajectory: how it follows instructions, calls tools, checks itself after a mistake, and talks to you along the way. AgentLens moves the target from the result to the process.

Where formal verification can decide objectively, it uses formal verification. Where it can't, an LLM writes a readable trajectory review, paired with side-by-side comparisons across versions. The authors use it to diagnose model behavior, compare iterations of their own agent, and catch product regressions in a nightly evaluation pipeline. Those uses sit closer to daily work than ranking models does.

An LLM-written review carries its own bias, so whether it can replace human review depends on the consistency data in the full paper. Still, turning "the process" into a signal you can evaluate and compare has real value for selection and tuning.

Key takeaways: - A single pass/fail hides an agent's most dangerous difference — whether it can recover after a mistake. - Trajectory-level review fits into a nightly pipeline to catch product regressions, more sustainable than manual review. - The benchmark is open source, so teams building agent products can wire it straight into their own iteration loop.

Source: AgentLens: Production-Assessed Trajectory Reviews for Coding Agent Evaluation

03 Bolt A Sparse Memory Bank Onto Linear Attention

Linear attention models have a structural advantage: fixed state size, fixed per-token compute, so long-context inference cost doesn't blow up. The price is a small state. On long context, remembering what was said earlier has always lost to standard softmax attention. The obvious fix is a bigger state, but FLOPs rise with it and the advantage disappears.

Sparse Delta Memory (SDM) breaks that linear link. Building on Gated DeltaNet, it swaps the dense key-value outer product for sparse reads and writes over a large explicit memory bank. State capacity grows by orders of magnitude, but each step touches only a small part, so compute stays flat. The paper also makes the memory bank's initial state a learnable parameter, letting it double as parametric memory and lift performance on commonsense and reasoning tasks.

Whether "grow state, not compute" pays off comes down to what recall actually buys at equal FLOPs and equal parameters. That needs the controlled experiments in the full paper.

Key takeaways: - Sparse addressing is one concrete way to scale a linear RNN's state while holding down FLOPs, worth comparing against your own approach if you work on long-context or reasoning efficiency. - The paper claims clear recall gains at equal FLOPs and parameters, but fixing recall in linear attention is a known hard problem, so the exact numbers need the full data. - Making the memory bank's initial state learnable lets one structure serve as both working memory and knowledge base — a design idea worth noting.

Source: Sparse Delta Memory: Scaling the State of Linear RNNs through Sparsity

04 Async RL Bought Throughput And Left Stability Behind

Most async RL chases one metric — throughput — and leaves stability aside. Synchronous, batch-interleaved pipelines running long-horizon agentic tasks make fast rollouts wait on slow ones, wasting compute. Async RL updates the moment a rollout arrives, which lifts throughput but says nothing about whether training stays stable or the task gets done. GRPO makes this worse: its group sampling was never built for the async setting.

SAO (single-rollout asynchronous optimization) runs one rollout per prompt, pairs it with a value-model training design to cut off-policy bias, and adds strict two-sided token-level clipping to steady the optimization. The result trains stably for a thousand steps and consistently beats GRPO and its variants on agentic benchmarks like SWE-Bench Verified and math reasoning. It already runs in the training pipeline for the open GLM-5.2 (750B-A40B).

For anyone building agentic RL systems, the lesson is that async isn't a free lunch. After the speedup, the hard part is holding stability and task performance together.

Key takeaways: - GRPO's group sampling doesn't fit async agentic training; SAO switches to single-rollout sampling to cut off-policy bias. - The real difficulty in async RL isn't throughput but the training stability and task performance that follow the speedup. - It already ships in a model as large as GLM-5.2, so this is a scale-tested method, not a paper design.

Source: Single-Rollout Asynchronous Optimization for Agentic Reinforcement Learning