GLM-5.2 worm hits 8/8, Claude CoT guard cracked, looped transformers hide state

Sources

AI models may be capable of self-replicating without access to a datacenter anthropic.com

Strengthening our defenses against distillation attacks anthropic.com

Towards Looped Models Done Right, Part II: Rethinking at Fixed Points huggingface.co

Every recurrence of a looped language model adds cost in training, decoding, prefill, and reinforcement learning (RL). The closer recurrent states get to fixed points, the less the path to them matters. This enables truncated backpropagation in training; terminal key-value (KV) sharing for decoding with almost no loss in accuracy; a distilled student that prefills up to 1.79x faster; and RL updates that compute gradients from saved rollout states, 2x faster than backpropagating through the repla

LiFT: Loop Flow Transformers huggingface.co

We introduce Loop Flow Transformers (LiFT), a family of looped generative models that scales computation by repeatedly applying a shared Diffusion Transformer (DiT) core, with only light changes to the standard architecture. Rather than asking every recurrent step for the final prediction, LiFT trains each step with a single regression target: a point on a straight path from the model’s initial estimate to the flow-matching target. Because we index these targets by a continuous depth coordinate,

How to Loop MoE: Flatten the Experts, Untie the Attention huggingface.co

Looped Transformers reuse one block of layers several times: by spending extra computation they push a model of fixed size further, and so use its parameters more fully; while sparse mixture-of-experts (MoE) models activate only a few of many experts for each token. Looped MoE bridges these two design philosophies and gives MoE models new potential for better expert usage, but it raises a question: how to loop a MoE? We answer it with Foil. With the expert parameters and the expert compute per t

Kandinsky 6.0 Video: Foundation Models for Synchronized Video and Audio Generation huggingface.co

Kandinsky 6.0 Video releases 3B Lite and 29B Pro diffusion models that jointly generate 5-second clips with lip-synced 44 kHz audio from text or image prompts. A built-in super-resolution stage upscales output to 1920x1080, and code is published on GitHub under the Kandinsky Lab repo.

LLM-as-Jev: LLMs Are Already Jev-Style Decision Models — When and How to Fine-Tune Them huggingface.co

Jev-style models return calibrated probability distributions over fixed options instead of free-form text, letting software act directly on outputs. New work shows LLMs already behave this way via next-token logits, applies the idea to System-1 search agents, and matches LLM fact extraction for conversational memory on LoCoMo.

SearchJev: A Fast and Calibrated System-1 Model for Search Agents huggingface.co

Search agents repeatedly make short decisions about relevance, evidence sufficiency, and search actions. Using generative language models for these decisions introduces latency and unreliable confidence. We present SearchJev, a fast and calibrated System-1 model that separates search decisions from System-2 reasoning and generation. Given a search state and a decision schema, SearchJev directly scores legal options without autoregressive output generation. We propose Soft-Label Learning for Cali

When Does Selection Replace Extraction? A Pre-Registered Test of Agent Memory with a Typed Decision Model huggingface.co

Does conversational memory need LLM-extracted facts, or is selecting the right raw turns enough? Published results disagree. Extraction-based systems report gains from distilled facts. Recent studies find raw history with good ranking does as well, but disagree about whether ranking matters. We ran a pre-registered study on held-out LoCoMo conversations and LongMemEval. At a tight budget on LoCoMo, raw turns selected by a single call to Jev, a typed decision model, are non-inferior to an LLM-ext

LoGRA: Scaling LLM Reinforcement Learning with Low-Rank Gradient Sketches huggingface.co

LoGRA compresses reinforcement learning gradients into low-rank sketches that drive both model updates and policy synchronization, lowering the memory wall that blocks RL at scale. Predictive clipping guards against oversized updates, preserving learning signal while shrinking the footprint of LLM post-training.

RealtimeWAM: One-Step Asynchronous World Action Models huggingface.co

RealtimeWAM attacks the two bottlenecks in Mixture-of-Transformers world action models: multi-step action denoising and sequential video-then-action execution. It distills action prediction to a single step and overlaps the two experts asynchronously, targeting real-time control without giving up the shared video backbone.

DeskForge: Dense Supervision from Desktop Environments for Computer-Use Agents huggingface.co

DeskForge spins up real applications in a controllable desktop environment, varying window layouts, content, and app state to produce large-scale annotated scenes. The pipeline targets a weak spot for computer-use agents: grounding clicks among overlapping windows and visually similar controls that existing datasets rarely cover.

When to Switch: Reliable Action-Chunk Extension for Vision-Language-Action Models huggingface.co

Long action chunks let vision-language-action robots skip costly policy calls but drift as predictions reach further ahead. RACE-VLA analyzes where errors appear inside a chunk and triggers re-planning only when reliability drops, replacing stop-and-go execution with smoother motion and faster task completion.

Periscope: Extending Frozen Language Models Beyond Their Context Window huggingface.co

Periscope factorizes long-document reading for selection tasks by tiling N chunks onto a sqrt(N) by sqrt(N) grid and querying a frozen model about local spans. The training-free method targets questions with finite answer sets, such as picking the relevant document or supporting passage, beyond the native context limit.

Optimizing the Optimizer: Language Models Discover Faster Molecular Relaxation huggingface.co

Geometry optimization is a major cost in many quantum-chemical workflows: each optimization step requires one force evaluation, and at the density-functional level that evaluation dominates the wall time. Research in this area has produced a broad range of optimization methods, and we ask whether a language model can improve on the best of them through autoresearch. An agent rewrites the optimizer itself to minimize force-call counts, restrained by two admission gates that reject premature stopp

Base Models Can Reason By Taking a Cue From Training Data huggingface.co

In this paper, we study how training data creates associations between the tokens at the start of a base model’s response and the reasoning behavior that follows. First, we demonstrate that fixing particular starting token cues makes a base model’s performance competitive with that of its reinforcement learning (RL)-trained counterparts on math and coding. For instance, the cue ”.\n\nOkay” raises Olmo-3-7B’s MATH-500 pass@1 accuracy from 42% to 78%, while “Alright,” raises Qwen3-14B’s from 72% t

OSWorld-Pro: Process-based Evaluation for Computer Use Agents huggingface.co

Evaluation of Computer-Use Agents (CUAs) is often limited to the final deliverables they create (at the end of hundreds of steps) and assessed with functional verifiers, as seen in OSWorld. However, such evaluation of end-state performance lacks transparency into how and why agents fail in various tasks, obfuscating critical insight for subsequent improvement. For instance, agents that err during keyboard inputs would require a different mitigation strategy from those that fail to precisely prov

UndoBench: Separating Task Competence from Recovery Capability in Tool-Using AI Agents huggingface.co

Tool-using AI agents are increasingly deployed across enterprise software systems, yet widely used benchmarks primarily evaluate nominal task completion, conflating baseline planning competence with operational fault recovery. We introduce UndoBench, a benchmark spanning 36 base workflows and 36 fault scenarios across 8 enterprise domains, decoupling task competence from recovery capability via counterfactual paired trials under identical seeds alongside wire-level effect-history and environment

The Missing Primitive: Diagnosing and Repairing Mathematical Reasoning in Large Language Models huggingface.co

While Large Language Models (LLMs) have demonstrated striking capabilities on frontier mathematical problems, it remains unclear whether they possess the structural mathematical understanding underlying their solutions. In this paper, we take a first step toward systematically studying mathematical understanding in LLMs, from diagnosing its distinct capabilities to leveraging these findings to improve post-training. First, we introduce the notion of Mathematical Primitive to probe structural mat

What Matters for Latent Reasoning with Flow Matching huggingface.co

Latent reasoning lets a large language model (LLM) think in a continuous space and verbalize only the answer. We argue that an effective latent thought must meet five requirements: it should be useful, helping produce the correct answer rather than merely changing it, diverse, so that resampling yields different reasoning trajectories, explainable, so that a decoded chain of thought (CoT) reflects reasoning the answer actually follows, refinable with more inference compute, and efficient, costin

What Gradients Add to Text Leakage in Split Language Models, Counted per Token and per Document huggingface.co

Split learning lets a client train a language model on a server without sending its text. The client runs the first layers itself and sends the server only their output, a vector of numbers for each token. During training, the server sends gradients back. We show that an observer at the split can rebuild most of the client’s text from this traffic, and we measure how much the gradients help. On GPT-2, an attacker who holds only the publicly released weights of the client’s layers recovers 94.20%

Noise Out, Bias In: Targeted Bias Injection in Diffusion Language Models via Closed-Loop Activation Steering huggingface.co

Masked diffusion language models (dLLMs) generate text by iteratively denoising masked positions, re-predicting each token multiple times before it is committed. An autoregressive decoder exposes an answer’s distribution once, at the step that commits it; a dLLM exposes it at every denoising step before commitment, and we show that an adversary can exploit this. Since an answer remains open to revision over many denoising steps, an adversary with access to internal activations can watch how like

Certification of Real Images through Calibrated Content Authentication huggingface.co

Generative models can synthesize high-quality inauthentic multimedia content that is already being misused at scale. We evaluate twenty deepfake detectors against ten generators released in the last four years and find accuracy decreasing over time, from near-perfect 99.5% to 76%. Adversarial perturbations further reduce every baseline detector to below 2% accuracy, effectively inverting the detector’s assigned label. We argue that this unreliability reflects a fundamental ambiguity: generators

World Editing: Intervening on Executable Worlds at Increasing Depth huggingface.co

Interactive world models are increasingly capable of generating environments and acting within them, yet deliberately editing an existing executable world remains underexplored. We formulate world editing as intervening on an existing world while preserving properties that should remain unchanged, and introduce intervention depth as an axis describing how strongly an edit couples world entities, dynamics, and systems. We instantiate this capability through industry-grade game modding and introdu

In-Distribution Forcing for Long Video Generation at Test Time huggingface.co

Modern autoregressive (AR) video diffusion models excel at short-horizon video generation, yet generating long videos remains challenging due to drifting, where colors and textures shift, and motion dynamics decay. Existing works primarily rely on KV conditioning, which selects or modifies cached key-value (KV) entries to mitigate drifting. However, we observe that KV conditioning alone is insufficient as it assumes cached KV entries remain in-distribution. This assumption fails beyond the train

HLA-WM: Hybrid Linear Attention for Long-Horizon Video World Models huggingface.co

Long-horizon video world models require persistent memory to preserve scene consistency over extended rollouts. Softmax attention retains the full generation history through a growing KV cache, whereas recurrent linear attention compresses history into fixed-size states with substantially lower memory cost. However, we identify severe long-range forgetting in Gated DeltaNet (GDN), where information from distant but relevant scenes is progressively attenuated by subsequent state updates. To addre

Prism: Dynamic Sparse Attention for Native 2K Joint Video-Audio Generation Model Training huggingface.co

Natively training joint video-audio generation models at higher resolutions empowers them to learn richer visual details and sharper motion dynamics. However, full attention incurs quadratic cost and, as resolution increases, spreads attention over increasingly redundant tokens, diluting learning signals for informative content and disrupting pretrained priors. Existing sparse attention methods either target training-free acceleration or overlook the unique structure of joint video-audio data, w

Rethinking Long-Video Efficiency: A Joint Allocation Perspective on Frames, Pixels, and Front-End Latency huggingface.co

Efficient long-video understanding with vision-language models (VLMs) is often framed as selecting informative frames or visual tokens at a fixed native resolution. We show that per-frame resolution can instead be traded for denser temporal coverage, while front-end decoding latency depends on the size of the candidate pool rather than the final token budget. An empirical study across multiple VLMs and long-video benchmarks yields three findings: dense low-resolution sampling outperforms sparse

PerturBot: Breaking Shortcut Priors in Vision-Language-Action Models with Perturbative Training huggingface.co

A vision—language—action (VLA) policy can complete complex tasks while ignoring the evidence that should determine its actions. An object held near the wrist camera can displace the instructed target. Language and action show the same pattern: a familiar noun can trigger the operation it was paired with in training even after the verb changes, and a gripper that closed on nothing may lift anyway. We call these dependencies modality shortcuts: regularities in successful demonstrations make visu

RobotUse: Allocating Computation, Context, and Decisions huggingface.co

Robot agents must connect their intended actions to observed outcomes while retaining the context needed to revise their choices over repeated attempts. Existing interfaces often leave these choices inside predefined tools or require agents to manage detailed execution code and its growing history. We introduce RobotUse, a robot agent harness that organizes computation, context, and decisions around specifying and revising physical actions. Agents visually select targets and poses, while the bac

ALoDLM: Adaptively Looped Diffusion Language Models huggingface.co

Diffusion language models (DLMs) enable fast generation by predicting multiple tokens in parallel, but their practical adoption remains limited by a persistent quality gap relative to comparably sized autoregressive (AR) models. We attribute this gap to a computation-difficulty mismatch: within a partially observed sequence, some unknown tokens are easy to predict, while others require substantially more computation. Existing DLMs nevertheless apply uniform computational depth to all unknown pos

Representation-Space MMD for Diffusion Language Models huggingface.co

We introduce a post-training method for diffusion language models (DLMs) that minimizes Maximum Mean Discrepancy (MMD) between generated and reference distributions in the feature space of a frozen pretrained DLM. To estimate MMD, we retain contextual features at individual token positions, obtaining multiple observations per sequence from a single extractor pass. We optimize this objective using policy gradients for discrete models and direct differentiation through generated latents for contin

Memadapter: Counterfactual Adaptation Against Memory-induced Sycophancy huggingface.co

Long-term memory enables LLM-based agents to retain and reuse information across tasks and sessions, supporting personalization and long-horizon interactions. However, persistent memories can also induce sycophancy, causing agents to over-align with users’ historical beliefs even when they are inaccurate, outdated, or inconsistent with objective evidence. Existing mitigation methods assume that memory-induced sycophancy originates from biased or incorrect memories and attempt to reduce this risk

ASCENT: Online Test-Time Training of Long-Horizon Agents via Self-Distillation of Verified Experience huggingface.co

A large language model (LLM) agent solves long-horizon tasks through many reasoning-action turns, with one verification signal at termination. Deployed agents face streams of related tasks, making their trajectories a natural resource for improvement. In-context adaptation agents store reflections, memories, or skills as text, so reuse depends on retrieving the right experience and on a frozen policy executing it. We study Online Agentic Test-Time Training (OaTTT), which trains the LLM’s weights

Capability-Driven Self-Evolution of Agent Memory huggingface.co

Memory self-evolution uses task feedback to iteratively improve executable memory programs that store and retrieve information from past interactions. Existing approaches typically adopt holistic evolution, deriving revision directions from mixed feedback and judging progress by overall performance. This can obscure optimization directions and hide capability-specific gains offset by regressions elsewhere, leaving promising directions underexplored. We introduce capability-driven evolution, whic

From Knowledge Access to Source Learning: Developing Source-Specific Competence huggingface.co

Large language model (LLM) agents increasingly rely on persistent external sources to solve sequences of knowledge-intensive tasks. Existing methods improve how source content is accessed and organized, while agent-memory systems preserve reusable knowledge from prior interactions, but repeated use of the same source is still largely treated as repeated access rather than an opportunity to progressively improve understanding of that source. We study source learning: developing reusable source-sp

SEER: Self-Evolving Event Reasoning and Retrieval for Time Series Forecasting huggingface.co

Real-world time series are frequently driven by exogenous events and structural shifts, rendering conventional forecasting based solely on historical numerical observations insufficient. While language models can retrieve external news, standard retrieval-augmented approaches struggle with high noise, missing signals, and an inability to reason causally about event impacts. We propose SEER (Self-Evolving Event Reasoning and Retrieval), a closed-loop framework that dynamically optimizes event con

CANOPY: Adaptive-Granularity Evidence Compression for Multimodal RAG huggingface.co

Multimodal RAG retrieves text, tables, images, and videos, but choosing a retrieval granularity does not determine how much context to retain within each item. Coarse units include irrelevant content, while uniformly fine selection can remove context needed to interpret the evidence. Existing compressors address this trade-off with modality-specific mechanisms, leaving open a shared procedure for adapting the retained extent region by region across heterogeneous items. We introduce CANOPY (Canon

Beyond Semantic Similarity: Performance and Costs of Agentic Retrieval for Complex Tasks huggingface.co

Modern information systems, including many agentic workflows, use dense retrieval to explore large amounts of unstructured data. However, dense retrieval relies on surface-level semantic similarity, which is insufficient for increasingly complex search applications. Here, we investigate agentic retrieval that combines the reasoning capabilities of Large Language Models (LLMs) with the efficient corpus exploration of retrievers in a ReAct agentic loop to solve complex retrieval tasks. In our expe

LMBuild: Evaluating LLM Agents for Generating Buildable and Functional Structures huggingface.co

LLM-based agents are increasingly capable of generating complex 3D structures, with the potential to reshape how objects are designed and realized in the physical world. Yet, producing elegant geometry is fundamentally different from producing objects that can be built and perform their intended functions. Existing evaluations largely focus on geometric quality while overlooking physical realizability. We introduce LMBuild, a benchmark for evaluating LLM agents on generating buildable and functi

Foundations of Proactive Agents: Principles, Technical Layers, and Proactivity-Gym huggingface.co

Proactive LLM agents can turn idle compute into useful support before users ask. Yet even correct work can misread user context, impose review costs, or undermine trust. This work proposes foundations for designing, realizing, and evaluating proactive LLM agents around three joint principles (3T): Task Capability, anticipating relevant needs and correctly performing useful work; Temporal Allocation, allocating compute according to resource availability and when results are needed; and Trust, sus

ProgressCompass: Embodied Progress Reward Models Are Lost Without the Right Context huggingface.co

Embodied agents now take on ever longer tasks. For long tasks, knowing only whether a task finally succeeds or fails says little; the steps along the way matter. Progress Reward Models (PRMs) score how far a task has come at every step, and serve as dense rewards, verifiers and monitors. Yet in long tasks the current frame alone often cannot tell how far the task has come, because progress depends on what happened before. We call this problem context-dependent progress estimation. Existing bench

Video2Skill: From Streaming Experience to Reusable Embodied Skills huggingface.co

Manipulation behaviors vary widely across objects and scenes, but they share a small set of reusable skills, and planning with these skills helps embodied agents generalize to new tasks. Yet an agent can only plan with skills it knows. Recovering skills from observed experience, the inverse of planning, builds this knowledge over time and yields skill data for training future agents. Vision-Language Models (VLMs) describe individual manipulation events well, but can they organize a stream of eve

OmniReasoning: Pushing the Limits of Audio-Visual Joint Reasoning huggingface.co

Recent advances have enabled unified omni-modal models in understanding audio, vision, and language. However, existing benchmarks, training data, and learning methods largely treat the modalities independently, leaving the capability of audio-visual joint reasoning poorly evaluated and insufficiently elicited. We address this gap with a benchmark, data engine, and learning method. First, we introduce OmniReasoningBench, a benchmark where both audio and visual evidence are indispensable. It compr

Data Unlearning via Inverse Distillation huggingface.co

Multi-step matching models, including flow and diffusion models, produce high-quality outputs but incur substantial inference costs and may reproduce unwanted components of their training datasets. We introduce Inverse Distillation Unlearning (IDU), a unified framework that simultaneously distills a teacher multi-step matching model into an efficient one-step student generator and suppresses outputs corresponding to a designated training subset. We first formulate distillation as a min-max objec

Empirical Variational Autoencoder huggingface.co

We present Empirical Variational Autoencoder, a general generative framework for continuous-valued (i.e., non-vector-quantized) sequences. EVA is based on the evidence lower bound of the Variational Autoencoder (VAE) but learns autoregressive latent priors empirically from training data, which can be implemented only by an additional single linear layer on top of VAEs. By replacing the conventional standard-Gaussian constraint with the self-predicted priors, EVA significantly alleviates the late

TextReg: Mitigating Prompt Distributional Overfitting via Regularized Text-Space Optimization huggingface.co

Large language models (LLMs) are highly sensitive to the prompts used to specify task objectives and behavioral constraints. Many recent prompt optimization methods iteratively rewrite prompts using LLM-generated feedback, but the resulting prompts often become longer, accumulate narrow sample-specific rules, and generalize poorly beyond the training distribution. We study this failure mode as prompt distributional overfitting and argue that it reflects a lack of representation control in discre

PaLoRA: Paced Low-Rank Adaptation for Continual Learning huggingface.co

LoRA-based continual learning methods mitigate catastrophic forgetting through various mechanisms, yet nearly all complement these with small learning rates as a heuristic to restrict gradient scaling magnitude. Such fixed heuristics lack theoretical guidance on how the strength of this restriction should evolve as tasks accumulate. We reveal that even under directional constraints such as nullspace projection, finite-precision updates inevitably leak into the subspace of accumulated prior knowl

Self-Generated Feedback Destabilizes Test-Time Training: A Causal Decomposition of Long-Horizon Adaptation huggingface.co

Test-time training (TTT) lets a model store information in its weights during inference. When the model learns from its own output, however, each update also changes the model that generates the next training example. Across 128K-token streams, retaining generated-text updates worsens prediction on independent human-written text with three TTT-E2E model configurations (labeled 125M, 760M, and 3B). The same failure occurs when Adam updates Qwen3-4B’s existing weights. The same update mechanisms c

Dynamic Harness Search: Building Multi-Agent Systems Per-Query via Prediction huggingface.co

Agent harnesses specify the roles, instructions, tools, and communication structure used to solve a task, and the right harness depends on the query. Because the value of each design choice is observable only through execution, tailoring a harness to each query has required either executing alternatives at inference time or costly manual design. We introduce SHIFT, which moves execution out of the per-query search loop. A local LLM architect learns a policy over harness-building actions from sea

Training Numerical Intelligence via Auto-Diagnosis and Skill Discovery huggingface.co

AI agents are becoming increasingly capable of generating scientific code, but generating code is not the same as improving the algorithms behind it. For numerical solvers, execution feedback can expose poor performance, but rarely reveals its underlying cause and how to address it. We introduce Auto-Diagnosis and Skill Discovery (ADSD), a framework that links numerical diagnosis to reusable solver self-improvement. ADSD follows a diagnosis-first paradigm that first explains why a solver perform

QuantCode Model: Specializing Language Models for Executable Algorithmic Trading Code huggingface.co

Large language models are strong general-purpose code generators, but executable algorithmic trading remains a demanding specialization target: a model must translate a natural-language strategy specification into correct program logic for a specialized trading framework, execute on historical data, produce trades, and remain semantically faithful to the request. We study two complementary mechanisms for specializing language models for this setting: continued pretraining on algorithmic-trading

References

explainx.ai — summary of Panfilov et al. ‘Stealing Reasoning Traces’ (arXiv, Aug 2026) explainx.ai

Encrypted reasoning blocks returned by the API can be ‘replayed’ into a weaker sibling model within the same ecosystem… attackers could effectively use a smaller model like Claude Haiku to decode the thoughts of a larger model like Claude Opus in plaintext.

mixed-news.com on Anthropic’s billable-blocks policy mixed-news.com

Billable blocks return an HTTP 200 with stop_reason: ‘refusal’ and an empty content array, yet incur token charges… developers describe it as a ‘tax on failure’ and report self-blocking where Claude’s own progress notes trigger the reasoning-extraction filter.

Anthropic docs — Preserved Thinking (platform.claude.com) platform.claude.com

For API accounts created on or after August 31, 2026, signature verification is enforced on thinking blocks; editing or reordering earlier messages causes the API to return a 400 error or drop subsequent reasoning blocks entirely, effectively banning client-side compaction.

Reddit r/kimi — Moonshot employee response reddit.com

The 14-day window between the release of Claude Fable 5 and Moonshot’s Kimi K3 made it technically impossible to have trained a frontier model via distillation in such a timeframe.

Anthropic — GLM-5.3 cyber capabilities report anthropic.com

GLM-5.3 built end-to-end exploits in 50 of 410 ExploitBench attempts, nearly matching Claude Mythos’s 56; its refusal mechanisms could be bypassed 64–100% of the time, or suppressed entirely via abliteration costing roughly $1,200–$4,400 in compute.

Quartz — China’s Cyberspace Administration probe qz.com

China’s Cyberspace Administration has launched its own probe into Moonshot, concerned that sensitive domestic data and PLA-linked information are being exported to American AI labs through these distillation pipelines.

Sebastian Raschka — LLM Architecture Gallery sebastianraschka.com

Looped/depth-sharing models trade parameters for compute: they are compute-heavy but parameter-light, which is almost the mirror image of MoE, which is parameter-heavy but compute-light.

Nabu Commentary on LiFT (arXiv:2610.05538) nabu.science

The practical case for LiFT rests on analytic FLOPs rather than measured wall-clock latency, energy, or peak memory, and the B/2 configuration failed to overtake dense baselines — suggesting the looped benefit only materialises past a certain core size.

arXiv:2609.35751 — How to Loop MoE (Foil) arxiv.org

The most flattened Foil configuration reduces pretraining loss by 0.012 nat at 100B tokens over compute-matched baselines; untying attention adds negligible FLOPs but is necessary — gains vanish in a fully tied loop.

Latent Chain-of-Thought? Decoding the Depth-Recurrent Transformer (ResearchGate) researchgate.net

We find limited evidence of human-interpretable logic within the latent loops; hidden states are often inconsistent across recurrent blocks, and recurrence depth gives only marginal gains over models that externalise reasoning in natural language.

ValueAdd VC — Recurrent-depth safety brief valueaddvc.com

Buck Shlegeris warned that scaling recurrent depth could ‘totally destroy CoT monitorability’; Ryan Greenblatt framed the endpoint as models reasoning in ‘neuralese’, removing humans from the oversight loop.

Paul Kuo — looped transformer scaling notes paulkuo.tw

Scaling-law work puts the recurrence exponent φ at roughly 0.46 — one extra loop is worth about half a unique layer block — and looped models consistently trail dense transformers on parametric-knowledge tasks even as they close the gap on reasoning.