The work targets tasks that exceed a single context window or prompt session. Builds OpenMLE around four composable operators, Draft, Improve, Debug, Crossover, that compose into long-horizon search strategies, and trains a 35B execution-grounded model on them.

Use Frontis-MA1: Training an AI4AI Model towards Recursive Self-Improvement in Machine Learning Engineering to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2607.28568; inspect its method and evaluation before treating results as production evidence.

[2607.28568] Frontis-MA1: Training an AI4AI Model towards Recursive Self-Improvement in Machine Learning Engineering

Recursive self-improvement (RSI) requires AI systems that improve the process of building AI (i.e., AI4AI); machine learning engineering (MLE) offers a concrete, executable testbed for studying this capability. We introduce OpenMLE, an open full-stack system for RSI research in MLE, spanning verifiable task environments with execution feedback (OpenMLE-Gym), operator learning (OpenMLE-RL), and long-horizon search (OpenMLE-Evo). On this stack we post-train Frontis-MA1 (35B) as a meta-evolution agent for MLE, aligning post-training and inference around four atomic program-evolution operators (Draft, Improve, Debug, Crossover): the same operators are trained via execution-grounded SFT and RL on data deduplicated against all evaluation benchmarks, then composed into long-horizon search, coupling learning and evolution in a single loop. On MLE-Bench Lite under a 12-hour per-task budget on one RTX 4090 capped at 12 GB VRAM, Frontis-MA1 (35B) improves Medal Average from 39.39% to 60.61% over its base model with OpenMLE-Evo, and reaches 71.21% with OpenMLE-Evo-Max (benchmark-independent experience priors and asynchronous search), exceeding GPT-5.5 + Codex and approaching GPT-5.6 Sol and the 2.8T Kimi K3. On held-out NatureBench Lite, both components transfer: with the framework fixed, swapping in the trained model raises Match-SOTA from 50% to 70%; with the model fixed, swapping in OpenMLE-Evo raises it from 20% to 50%. We release the model weights and the full OpenMLE stack to enable reproducible research on executable AI4AI toward RSI. Code: https://github.com/FrontisAI/OpenRSI

Junlin Yang; Che Jiang; Yu Fu; Tianwei Luo; Can Ren; Weizhi Wang; Kaikai Zhao; Hongyi Liu; Yuxin Zuo; Yuru Wang; Yuchen Fan; Kai Tian; Zhenzhao Yuan; Xiaojian Lin; Li Sheng; Rushi Qiang; Guoli Jia; Xingtai Lv; Ermo Hua; Dianqiao Lei; Youbang Sun; Ning Ding; Bowen Zhou; Kaiyan Zhang


Connects Loop Engineering to prior agent-loop and feedback-loop research. Names and measures the 'confidence cliff': as a self-improving autoresearch system accumulates successful modifications, its ability to predict which next idea will work collapses from ~83% to ~57%, so the loop degrades exactly when it looks healthiest.

Use Rehearse: Stepping Back from the Confidence Cliff in Self-Improving Autoresearch to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2607.27687; inspect its method and evaluation before treating results as production evidence.

Understand the field and its boundaries.

[2607.27687] Rehearse: Stepping Back from the Confidence Cliff in Self-Improving Autoresearch

Autoresearch improves machine-learning code by proposing changes, running full training jobs, and keeping changes that improve the metric. The efficiency of this loop depends not only on generating ideas, but also on the agent's ability to decide, before spending a training run, whether a proposed modification is likely to work. We study how the reliability of this pre-execution judgment changes over the course of an autoresearch trajectory. In public AutoSOTA logs (Li et al., 2026; Tsinghua FIB Lab, 2026), the fraction of helpful modifications falls from 70% in the first two iterations to 43% by iteration 6+. On 296 same-baseline modification pairs from 39 paper-derived AutoSOTA tasks, each containing one modification that improved the metric and one that did not, with measured outcomes hidden, an LLM judge given candidate rationales but no prior-attempt history reaches 79.5% accuracy on the pairs where strict consensus returns a verdict. On the full 366-pair benchmark, however, this ability weakens substantially late in the loop. As successful changes accumulate, selective accuracy - accuracy conditioned on a strict-consensus verdict - falls from 82.8% to 56.9%, while the judge remains willing to decide. We call this operational pattern the confidence cliff. Rehearse implements the loop change as a lightweight skill for autoresearch loops: propose several ideas, compare them before execution, run the most promising, and judge with a focused memory of similar past attempts and outcomes. This focused outcome memory raises late selective accuracy to 83.5%. Across 4,000 budgeted training runs over three loops, Rehearse improves the endpoint under the same training-run budget on nanochat, image classification, and time-series forecasting.


Control flow is represented as an inspectable graph rather than an opaque prompt loop. Diagnoses 'retrieval-equivalence collapse' in RL-trained search agents: during Search-R1 training, rollouts for the same question keep emitting distinct query strings while their accumulated evidence sets increasingly overlap, so trajectories converge to utility equivalence and within-group returns carry almost no retrieval contrast to learn from.

Use Harness-G: A Graph-Structured Harness for Search Agents to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2607.27652; inspect its method and evaluation before treating results as production evidence.

[2607.27652] Harness-G: A Graph-Structured Harness for Search Agents

Reinforcement learning (RL) search agents commonly model retrieval as free-form natural-language query generation and optimize multi-turn interactions using final-answer rewards. Current studies mainly improve training with denser or more structured credit signals, but rarely examine whether retrieval is properly formulated at the policy-environment interface. We observe pronounced retrieval aliasing during Search-R1 training: rollouts for the same question continue to generate distinct query strings, yet their accumulated evidence sets increasingly overlap. We call this phenomenon retrieval-equivalence collapse; in this regime, trajectories approach utility equivalence with respect to retrieval decisions, leaving within-group returns with little effective retrieval contrast. To address this problem, we propose Harness-G, a graph-structured retrieval framework that redesigns this interface. It reformulates free-form query generation as finite action selection: the policy selects an evidence sentence or entity, or chooses to answer, while the environment constructs the menu, tracks retrieval state, and validates and executes each choice. This interface reduces linguistic aliasing and makes same-state alternatives directly comparable. Building on this interface, we introduce Structured Non-myopic Credit (SNC), which uses a frozen answer scorer to compare the selected action with its alternatives and assigns downstream gains to the earlier actions that enabled them. Across six QA benchmarks, Harness-G achieves the highest average F1 at both evaluated model scales, outperforming the strongest baseline, Graph-R1, by 10.74 points at 1.5B and 3.98 points at 3B.

Yanning Hou; Haoyuan Chen; Sihang Zhou; Xiaoshu Chen; Xirui Liu; Duanyang Yuan; Lingyuan Meng; Siwei Wang; Quan Liu; Jian Huang


Universal Transformers

Reuses learned computation inside one model inference rather than repeating a full agent run. Introduces recurrent depth for Transformers by repeatedly applying shared self-attention and transition blocks, with optional per-position adaptive halting; establishes the architectural foundation for later looped models.

Use Universal Transformers to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source; inspect its method and evaluation before treating results as production evidence.

Understand how recurrent model computation can power, but not replace, a governed agent loop.

Mostafa Dehghani; Stephan Gouws; Oriol Vinyals; Jakob Uszkoreit; Łukasz Kaiser

International Conference on Learning Representations (ICLR)

Published at ICLR 2019; venue and authors verified from the official OpenReview record.


Reuses learned computation inside one model inference rather than repeating a full agent run. Constructs a constant-depth looped Transformer that advances an in-state program counter and executes reusable instructions, showing how iterative algorithms and in-context gradient descent can be represented through repeated shared computation.

Use Looped Transformers as Programmable Computers to assess inner latent computation as a model capability inside a separately governed agent loop.

Looped Transformers as Programmable ComputersAngeliki Giannou, Shashank Rajput, Jy-Yong Sohn, Kangwook Lee, Jason D. Lee, Dimitris P...

Angeliki Giannou; Shashank Rajput; Jy-Yong Sohn; Kangwook Lee; Jason D. Lee; Dimitris Papailiopoulos

International Conference on Machine Learning


Reuses learned computation inside one model inference rather than repeating a full agent run. Trains input-injected looped Transformers for in-context data fitting and shows that iterative shared computation can match standard Transformers on tested function classes with substantially fewer parameters.

Use Looped Transformers are Better at Learning Learning Algorithms to assess inner latent computation as a model capability inside a separately governed agent loop.

Liu Yang; Kangwook Lee; Robert D. Nowak; Dimitris Papailiopoulos

Published at ICLR 2024; venue and authors verified from the official OpenReview record.


Reuses learned computation inside one model inference rather than repeating a full agent run. Derives approximation rates for looped Transformers, identifies a loop-specific expressivity limit, and uses timestep-conditioned scaling to improve function approximation as recurrence increases.

Use On Expressive Power of Looped Transformers: Theoretical Analysis and Enhancement via Timestep Encoding to assess inner latent computation as a model capability inside a separately governed agent loop.

On Expressive Power of Looped Transformers: Theoretical Analysis and Enhancement via Timestep EncodingKevin Xu, Issei SatoLooped Transformers provide ad...


Reuses learned computation inside one model inference rather than repeating a full agent run. Connects effective recurrent depth to reasoning, proves that looped models can simulate multi-step chain-of-thought in latent space under the paper's construction, and studies the trade-off between reasoning and memorization.

Use Reasoning with Latent Thoughts: On the Power of Looped Transformers to assess inner latent computation as a model capability inside a separately governed agent loop.

ICLR Poster Reasoning with Latent Thoughts: On the Power of Looped Transformers ICLR 2025

Nikunj Saunshi; Nishanth Dikkala; Zhiyuan Li; Sanjiv Kumar; Sashank J. Reddi

International Conference on Learning Representations

Published at ICLR 2025; metadata verified from the official conference poster page.


Reuses learned computation inside one model inference rather than repeating a full agent run. Presents Huginn, a 3.5B recurrent-depth language model trained on 800B tokens whose shared core can be unrolled further at inference, with gains concentrated on reasoning tasks and support for adaptive compute and KV-cache sharing.

Use Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2502.05171; inspect its method and evaluation before treating results as production evidence.

[2502.05171] Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach

We study a novel language model architecture that is capable of scaling test-time computation by implicitly reasoning in latent space. Our model works by iterating a recurrent block, thereby unrolling to arbitrary depth at test-time. This stands in contrast to mainstream reasoning models that scale up compute by producing more tokens. Unlike approaches based on chain-of-thought, our approach does not require any specialized training data, can work with small context windows, and can capture types of reasoning that are not easily represented in words. We scale a proof-of-concept model to 3.5 billion parameters and 800 billion tokens. We show that the resulting model can improve its performance on reasoning benchmarks, sometimes dramatically, up to a computation load equivalent to 50 billion parameters.

Jonas Geiping; Sean McLeish; Neel Jain; John Kirchenbauer; Siddharth Singh; Brian R. Bartoldson; Bhavya Kailkhura; Abhinav Bhatele; Tom Goldstein

Neural Information Processing Systems Foundation

Published in Advances in Neural Information Processing Systems 38 (NeurIPS 2025); the linked arXiv record remains available for open access.


Reuses learned computation inside one model inference rather than repeating a full agent run. Combines shared recursive layers with token-level routers so difficult tokens receive more depth while attention and KV caching are restricted to active tokens.

Use Mixture-of-Recursions: Learning Dynamic Recursive Depths for Adaptive Token-Level Computation to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2507.10524; inspect its method and evaluation before treating results as production evidence.

[2507.10524] Mixture-of-Recursions: Learning Dynamic Recursive Depths for Adaptive Token-Level Computation

Scaling language models unlocks impressive capabilities, but the accompanying computational and memory demands make both training and deployment expensive. Existing efficiency efforts typically target either parameter sharing or adaptive computation, leaving open the question of how to attain both simultaneously. We introduce Mixture-of-Recursions (MoR), a unified framework that combines the two axes of efficiency inside a single Recursive Transformer. MoR reuses a shared stack of layers across recursion steps to achieve parameter efficiency, while lightweight routers enable adaptive token-level thinking by dynamically assigning different recursion depths to individual tokens. This allows MoR to focus quadratic attention computation only among tokens still active at a given recursion depth, further improving memory access efficiency by selectively caching only their key-value pairs. Beyond these core mechanisms, we also propose a KV sharing variant that reuses KV pairs from the first recursion, specifically designed to further decrease memory footprint. Across model scales ranging from 135M to 1.7B parameters, MoR forms a new Pareto frontier: at equal training FLOPs and smaller model sizes, it significantly lowers validation perplexity and improves few-shot accuracy, while delivering higher throughput compared with vanilla and existing recursive baselines. These gains demonstrate that MoR is an effective path towards large-model quality without incurring large-model cost.

Sangmin Bae; Yujin Kim; Reza Bayat; Sungnyun Kim; Jiyoun Ha; Tal Schuster; Adam Fisch; Hrayr Harutyunyan; Ziwei Ji; Aaron Courville; Se-Young Yun


Reuses learned computation inside one model inference rather than repeating a full agent run. Introduces the Ouro family of pretrained LoopLMs, combining latent iteration, learned depth allocation, and large-scale pretraining to study recurrent depth as a scaling axis distinct from parameter count and generated reasoning tokens.

Use Scaling Latent Reasoning via Looped Language Models to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2510.25741; inspect its method and evaluation before treating results as production evidence.

[2510.25741] Scaling Latent Reasoning via Looped Language Models

Modern LLMs are trained to "think" primarily via explicit text generation, such as chain-of-thought (CoT), which defers reasoning to post-training and under-leverages pre-training data. We present and open-source Ouro, named after the recursive Ouroboros, a family of pre-trained Looped Language Models (LoopLM) that instead build reasoning into the pre-training phase through (i) iterative computation in latent space, (ii) an entropy-regularized objective for learned depth allocation, and (iii) scaling to 7.7T tokens. Ouro 1.4B and 2.6B models enjoy superior performance that match the results of up to 12B SOTA LLMs across a wide range of benchmarks. Through controlled experiments, we show this advantage stems not from increased knowledge capacity, but from superior knowledge manipulation capabilities. We also show that LoopLM yields reasoning traces more aligned with final outputs than explicit CoT. We hope our results show the potential of LoopLM as a novel scaling direction in the reasoning era. Our model is available here: http://ouro-llm.github.io.

Rui-Jie Zhu; Zixuan Wang; Kai Hua; Tianyu Zhang; Ziniu Li; Haoran Que; Boyi Wei; Zixin Wen; Fan Yin; He Xing; Lu Li; Jiajun Shi; Kaijing Ma; Shanda Li; Taylor Kergan; Andrew Smith; Xingwei Qu; Mude Hui; Bohong Wu; Qiyang Min; Hongzhi Huang; Xun Zhou; Wei Ye; Jiaheng Liu; Jian Yang; Yunfeng Shi; Chenghua Lin; Enduo Zhao; Tianle Cai; Ge Zhang; Wenhao Huang; Yoshua Bengio; Jason Eshraghian


Reuses learned computation inside one model inference rather than repeating a full agent run. Trains variable-length latent trajectories with time and step-size conditioning plus shortcut consistency, allowing one model to trade compute for quality across inference budgets without retraining.

Use LoopFormer: Elastic-Depth Looped Transformers for Latent Reasoning via Shortcut Modulation to assess inner latent computation as a model capability inside a separately governed agent loop.

ICLR Poster LoopFormer: Elastic-Depth Looped Transformers for Latent Reasoning via Shortcut Modulation ICLR 2026

Ahmadreza Jeddi; Marco Ciccone; Babak Taati

Published at ICLR 2026; metadata verified from the official conference poster page.


Reuses learned computation inside one model inference rather than repeating a full agent run. Replaces a single recurrent reasoning path with dynamically routed LoRA branches, adding solution-space exploration and load-balanced routing to the Huginn-style depth-recurrent backbone.

Use MoDr: Mixture-of-Depth-Recurrent Transformers for Test-Time Reasoning to assess inner latent computation as a model capability inside a separately governed agent loop.

ICLR Poster MoDr: Mixture-of-Depth-Recurrent Transformers for Test-Time Reasoning ICLR 2026

Xiaojing Zhang; Haifeng Wu; Gang He; Jiyang Shen; Bochen Lyu; Zhanxing Zhu


Reuses learned computation inside one model inference rather than repeating a full agent run. Combines within-layer multi-substep state updates, state-guided sparse attention, across-layer recurrence, and adaptive stopping to increase latent reasoning depth without extending visible chain-of-thought.

Use ChainGPT: Dual-Reasoning Model with Recurrent Depth and Multi-Rank State Updates to assess inner latent computation as a model capability inside a separately governed agent loop.

ICLR Poster ChainGPT: Dual-Reasoning Model with Recurrent Depth and Multi-Rank State Updates ICLR 2026

Yunao Zheng; Xiaojie Wang; Lei Ren; Chen Wei


Reuses learned computation inside one model inference rather than repeating a full agent run. Learns when a token needs extra latent refinement, using a neural decider, depth-aware LoRA, and cross-iteration attention to avoid always paying for or being degraded by additional loops.

Use Think-at-Hard: Selective Latent Iterations to Improve Reasoning Language Models to assess inner latent computation as a model capability inside a separately governed agent loop.

Tianyu Fu; Yichen You; Zekai Chen; Guohao Dai; Huazhong Yang; Yu Wang

International Conference on Machine Learning (ICML)

Published at ICML 2026; venue and authors verified from the official OpenReview record.


Reuses learned computation inside one model inference rather than repeating a full agent run. Stabilizes very deep recurrence with pre-normalization and residual scaling, then uses latent-state convergence as the halting signal so the model allocates more iterations to harder Sudoku, maze, state-tracking, and ARC-AGI instances without a separate stopping head.

Use Fixed-Point Reasoners: Stable and Adaptive Deep Looped Transformers to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2606.18206; inspect its method and evaluation before treating results as production evidence.

[2606.18206] Fixed-Point Reasoners: Stable and Adaptive Deep Looped Transformers

Looped architectures provide an inductive bias toward learning step-by-step procedures for tasks that require compositional reasoning. The number of effective layers reached by looping determines the quality of the solution these models find. Like deep architectures, looped architectures are prone to a signal propagation problem induced by depth as the halting decision is postponed. In this paper, we address this signal propagation issue using pre-norm layers and residual scaling. Building on these architectural modifications, we propose FPRM, a Transformer-based Fixed-Point Reasoning Model that uses fixed-point convergence as an end-to-end halting mechanism in a looped architecture. We show that fixed-point halting allows FPRM to adapt its compute to task difficulty. FPRM is effective on common reasoning benchmarks, namely Sudoku, Maze, state-tracking, and ARC-AGI.

Sajad Movahedi; Vera Milovanović; Shlomo Libo Feigin; Alexander Theus; Thomas Hofmann; Valentina Boeva; T. Konstantin Rusch; Antonio Orvieto

Published in Proceedings of the 43rd International Conference on Machine Learning (ICML), PMLR 306; the linked arXiv record remains available for open access.


Loop the Loopies!

Reuses learned computation inside one model inference rather than repeating a full agent run. Introduces the Loopie family of sparse looped Transformers (20B parameters with 2B active and 6B with 0.6B active); the authors' matched-compute experiments over 3.5T pretraining tokens overtake a reproduced vanilla 30B-A3B baseline after roughly 600B tokens, while post-training plus test-time scaling reaches 35/42 on IMO 2025 and 20.3 on IPhO 2025. The paper announces preview weights and code, but those artifacts are not yet public.

Use Loop the Loopies! to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2607.16051; inspect its method and evaluation before treating results as production evidence.

We present the Loopie series, consisting of two Mixture-of-Experts (MoE) models: a 20B-parameter model with 2B active parameters and a 6B-parameter model with 0.6B active parameters. Looped Transformers have long faced a challenge: given an N times increase in pre-training compute, increasing the parameter count by a factor of N usually outperforms looping a model N times. Loopie addresses this challenge. Extensive ablation studies, including comparisons with a vanilla 30B-A3B model, show that Loopie substantially outperforms vanilla Transformer baselines trained with the same compute budget. With a novel post-training method, Loopie develops strong reasoning abilities and achieves frontier-level reasoning performance.

Zitian Gao; Yilong Chen; Yihao Xiao; Xinyu Yang; Ran Tao; Joey Zhou; Bryan Dai


Reuses learned computation inside one model inference rather than repeating a full agent run. Combines sparse expert routing with weight-shared recurrence through iteration-conditioned adaptive normalization and capacity balancing; under matched parameters, per-token FLOPs, and active-sublayer ratios, the reported 3B model beats its vanilla MoE control on 8 of 9 benchmarks by more than one point on average, with the advantage persisting at 9B.

Use LoopMoE: Unifying Iterative Computation with Mixture-of-Experts for Language Modeling to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2606.04438; inspect its method and evaluation before treating results as production evidence.

[2606.04438] LoopMoE: Unifying Iterative Computation with Mixture-of-Experts for Language Modeling

Mixture-of-Experts (MoE) and looped architectures scale models along two orthogonal axes, namely parameter capacity and effective depth. However, mainstream looped architectures rely on dense backbones that couple parameter count with per-token FLOPs, which makes it impossible to isolate the effect of iterative computation under matched budgets. To this end, we present LoopMoE, a looped MoE language model that integrates sparse routing with iterative weight-shared computation through two designs. The first is IterAdaLN, which resolves weight-sharing symmetry via a modulation signal jointly conditioned on the iteration index and the per-token hidden state. The second is a capacity-balancing strategy that recovers the attention-to-FFN active parameter ratio of well-tuned non-looped references. Together, these designs enable the first strictly controlled, head-to-head evaluation of a looped MoE against a Vanilla MoE under identical total parameters, per-token FLOPs, and active sublayer ratios. At the 3B scale, LoopMoE outperforms the Vanilla MoE on 8 of 9 downstream benchmarks with an average improvement exceeding 1 point. At the 9B scale, LoopMoE continues to outperform the matched Vanilla MoE, indicating that the architectural gain persists at larger scale. Our work establishes a controlled synthesis of sparsity and recurrence, and suggests a promising direction for looped language models.

Wenkai Chen; Tianshu Li; Wenyong Huang; Yichun Yin; Lifeng Shang; Chengwei Qin


Reuses learned computation inside one model inference rather than repeating a full agent run. Finds that dense looped models lose their scaling advantage while looped MoE models recover expressivity because routing diverges across repeated passes; also shows that loop boundaries form stronger early-exit points than arbitrary layers in standard Transformers.

Use Sparse Layers are Critical to Scaling Looped Language Models to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2605.09165; inspect its method and evaluation before treating results as production evidence.

[2605.09165] Sparse Layers are Critical to Scaling Looped Language Models

Looped language models repeat a set of transformer layers through depth, reducing memory costs and providing natural early-exit points at loop boundaries. However, looped models do not scale as favorably as standard transformers with unique layers. We compare standard and Mixture-of-Experts (MoE) transformers, with and without looping, and find two main results. First, we find Looped-MoE models scale better than the standard baseline while dense looped models do not. We trace this to routing divergence between loops: in Looped-MoE models, different experts are activated on each pass through the same shared layers, recovering expressivity without additional parameters. Our second finding is that looped models have better compute-quality trade-offs with early exits than standard models. Because each loop ends with the same layers that produce the final output, loop boundaries are superior exit points, as confirmed by earlier output convergence at these points. In sum, we provide a clear direction for scaling looped models: a Looped-MoE model with early exits can not only beat standard transformers at scale, but also enable significant memory and inference savings with minimal degradation in quality.

Ryan Lee; Jacob Biloki; Edward J. Hu; Jonathan May


Reuses learned computation inside one model inference rather than repeating a full agent run. Traces cyclic recurrence inside looped language models and finds that many studied layers converge to distinct fixed points, with attention behavior stabilizing as recurrent blocks repeat feedforward-like inference stages; tests how block size, input injection, and normalization shape those dynamics.

Use A Mechanistic Analysis of Looped Reasoning Language Models to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2604.11791; inspect its method and evaluation before treating results as production evidence.

[2604.11791] A Mechanistic Analysis of Looped Reasoning Language Models

Reasoning has become a central capability in large language models. Recent research has shown that reasoning performance can be improved by looping an LLM's layers in the latent dimension, resulting in looped reasoning language models. Despite promising results, few works have investigated how their internal dynamics differ from those of standard feedforward models. In this paper, we conduct a mechanistic analysis of the latent states in looped language models, focusing in particular on how the stages of inference observed in feedforward models compare to those observed in looped ones. To this end, we analyze cyclic recurrence and show that for many of the studied models each layer in the cycle converges to a distinct fixed point; consequently, the recurrent block follows a consistent cyclic trajectory in the latent space. We provide evidence that as these fixed points are reached, attention-head behavior stabilizes, leading to constant behavior across recurrences. Empirically, we discover that recurrent blocks learn stages of inference that closely mirror those of feedforward models, repeating these stages in depth with each iteration. We study how recurrent block size, input injection, and normalization influence the emergence and stability of these cyclic fixed points. We believe these findings help translate mechanistic insights into practical guidance for architectural design.

Hugh Blayney; Álvaro Arroyo; Johan Obando-Ceron; Pablo Samuel Castro; Aaron Courville; Michael M. Bronstein; Xiaowen Dong


Reuses learned computation inside one model inference rather than repeating a full agent run. Treats the recurrent block as a dynamical system, constrains its stability, and studies how training and test-time recurrence trade parameters for additional computation.

Use Parcae: Scaling Laws For Stable Looped Language Models to assess inner latent computation as a model capability inside a separately governed agent loop.

Hayden Prairie; Zachary Novack; Taylor Berg-Kirkpatrick; Daniel Y. Fu

Workshop paper at the Learning to Iterate Workshop at ICLR 2026; not an ICLR main-conference paper.


Reuses learned computation inside one model inference rather than repeating a full agent run. Recurs over progressively compressed representations so repeated layers specialize across resolutions instead of recomputing every token at full resolution.

Use SpiralFormer: Looped Transformers Can Learn Hierarchical Dependencies via Multi-Resolution Recursion to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2602.11698; inspect its method and evaluation before treating results as production evidence.

[2602.11698] SpiralFormer: Looped Transformers Can Learn Hierarchical Dependencies via Multi-Resolution Recursion

Recursive (looped) Transformers decouple computational depth from parameter depth by repeatedly applying shared layers, providing an explicit architectural primitive for iterative refinement and latent reasoning. However, early looped Transformers often underperform non-recursive baselines of equal compute. While recent literature has introduced more effective recursion mechanisms to mitigate this gap, existing architectures still operate at a fixed, full-token resolution, neglecting the potential efficiency of computing over compressed latent representations. In this paper, we propose SpiralFormer, a looped Transformer that executes recurrence under a multi-resolution recursion schedule. We provide probing evidence that multi-resolution recursion enables the model to learn hierarchical dependencies by inducing iteration-wise functional specialization across different scales. Empirically, SpiralFormer achieves better parameter and compute efficiency than both looped and non-looped baselines across model scales from 160M to 1.4B, establishing sequence resolution as a potential axis for scaling recursive architectures.

Chengting Yu; Xiaobo Shu; Yadao Wang; Yizhen Zhang; Haoyi Wu; You Wu; Rujiao Long; Ziheng Chen; Yuchi Xu; Wenbo Su; Bo Zheng


Training-Free Looped Transformers

Reuses learned computation inside one model inference rather than repeating a full agent run. Retrofits recurrence onto frozen pretrained models by applying a damped mid-stack block as smaller refinement steps, testing when inference-time looping helps without fine-tuning.

Use Training-Free Looped Transformers to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2605.23872; inspect its method and evaluation before treating results as production evidence.

[2605.23872] Training-Free Looped Transformers

We introduce training-free looped transformers, in which a lightweight inference-time wrapper loops a contiguous mid-stack block of layers of a frozen checkpoint without additional fine-tuning, continued training, or architectural changes. Unlike prior looped transformer methods that train with the looped structure end-to-end, we retrofit recurrence onto pretrained models at test time. We show that naive block reapplication usually degrades performance, highlighting the importance of the loop application strategy. Motivated by viewing a pre-norm transformer block as a forward Euler step on an ODE, we instead treat looping as a refinement of the same approximation, replacing one large update with smaller damped sub-steps. Across seven dense, sparse MoE, and MLA+MoE model families, our method improves Qwen3-4B-Instruct by +2.64 pp on MMLU-Pro, Qwen3-30B-A3B-Instruct by +1.14 pp on CommonsenseQA, and Moonlight-16B-A3B-Instruct by +1.20 pp on OpenBookQA.

Lizhang Chen; Jonathan Li; Chen Liang; Ni Lao; Qiang Liu


Reuses learned computation inside one model inference rather than repeating a full agent run. Shows systematic generalization and depth extrapolation in controlled recurrent-depth reasoning tasks while documenting overthinking when recurrence exceeds the useful computation horizon.

Use Loop, Think, & Generalize: Implicit Reasoning in Recurrent-Depth Transformers to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2604.07822; inspect its method and evaluation before treating results as production evidence.

[2604.07822] Loop, Think, & Generalize: Implicit Reasoning in Recurrent-Depth Transformers

We study implicit reasoning, i.e. the ability to combine knowledge or rules within a single forward pass. While transformer-based large language models store substantial factual knowledge and rules, they often fail to compose this knowledge for implicit multi-hop reasoning, suggesting a lack of compositional generalization over their parametric knowledge. To address this limitation, we study recurrent-depth transformers, which enables iterative computation over the same transformer layers. We investigate two compositional generalization challenges under the implicit reasoning scenario: systematic generalization, i.e. combining knowledge that is never used for compositions during training, and depth extrapolation, i.e. generalizing from limited reasoning depth (e.g. training on up to 5-hop) to deeper compositions (e.g. 10-hop). Through controlled studies with models trained from scratch, we show that while vanilla transformers struggle with both generalization challenges, recurrent-depth transformers can effectively make such generalization. For systematic generalization, we find that this ability emerges through a three-stage grokking process, transitioning from memorization to in-distribution generalization and finally to systematic generalization, supported by mechanistic analysis. For depth extrapolation, we show that generalization beyond training depth can be unlocked by scaling inference-time recurrence, with more iterations enabling deeper reasoning. We further study how training strategies affect extrapolation, providing guidance on training recurrent-depth transformers, and identify a key limitation, overthinking, where excessive recurrence degrades predictions and limits generalization to very deep compositions.

Harsh Kohli; Srinivasan Parthasarathy; Huan Sun; Yuekun Yao


Reuses learned computation inside one model inference rather than repeating a full agent run. Derives residual-scaling rules that account for repeated parameter visits and tests them on GPT-style looped language models, addressing instability that nominal layer depth alone misses.

Use DeepLoop: Depth Scaling for Looped Transformers to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2607.13491; inspect its method and evaluation before treating results as production evidence.

[2607.13491] DeepLoop: Depth Scaling for Looped Transformers

Looped Transformers scale sequential computation by applying a compact stack of physical blocks for multiple rounds, increasing unrolled depth without increasing stored parameters. This reuse changes the residual-scaling problem: in an untied Transformer, each residual branch receives and applies its own parameter update, whereas in a looped Transformer one shared update aggregates gradients from repeated visits and is read back by those same visits in the next linearized forward pass. We formalize this tied-depth effect through a first-order perturbation bound controlled by a visit-alignment coefficient $\kappa_R$. The bound recovers the DeepNorm exponent when visits decorrelate, but in the conservative aligned regime it requires the exponent to increase from $1/4$ to $1/2$ as loop count grows at fixed physical depth. The resulting method, \textbf{DeepLoop}, keeps the Post-LN DeepNorm architecture and sets $\alpha=(2N)^{1/2}$ and $\beta=(8N)^{-1/2}$ for unrolled depth $N$. On GPT-style looped language models at GPT-2 small and GPT-2 medium scale, DeepLoop is neutral when no physical block is revisited and improves validation loss and downstream accuracy once recurrent depth is activated. These results show that stable recurrent depth requires residual scaling rules that account for parameter visits, not only nominal layer count.

Shuzhen Li; Yifan Zhang; Jiacheng Guo; Quanquan Gu; Mengdi Wang


Reuses learned computation inside one model inference rather than repeating a full agent run. Separates recurrent passes from unique parameter depth and training compute to estimate when an additional loop is worth more than adding distinct layers.

Use How Much Is One Recurrence Worth? Iso-Depth Scaling Laws for Looped Language Models to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2604.21106; inspect its method and evaluation before treating results as production evidence.

[2604.21106] How Much Is One Recurrence Worth? Iso-Depth Scaling Laws for Looped Language Models

We measure how much one recurrence is worth to a looped (depth-recurrent) transformer, in equivalent unique parameters. From an iso-depth pretraining sweep across recurrence counts $r \in \{1, 2, 4, 8\}$ spanning ${\sim}50\times$ in training compute, we fit a joint scaling law $L = E + A\,(N_\text{once} + r^{\varphi} N_\text{rec})^{-\alpha} + B\,D^{-\beta}$ and measure a recurrence-equivalence exponent $\varphi = 0.46$. Intuitively, $\varphi$ tells us whether looping a block $r$ times is equivalent in validation loss to $r$ unique blocks of a non-looped model (full equivalence, $\varphi{=}1$) or to a single block run repeatedly with no capacity gain ($\varphi{=}0$). Our $\varphi = 0.46$ sits in between, so replacing unique blocks with shared recurrences increases validation loss at matched training compute. For example, at $r{=}4$ a 410M looped model performs on par with a 580M non-looped model, but incurs the training cost of a 1B non-looped one. We demonstrate the utility of $\varphi$ as a diagnostic tool on two case studies: commonly used truncated backpropagation lowers $\varphi$ to $0.38$, indicating that the loop mechanism is poorly trained under truncation, even though validation loss decreases. Conversely, hyperconnections raise $\varphi$ to $0.65$, a genuine capacity gain. Our method separates true loop improvements from training-side gains, a distinction raw validation loss cannot make.

Kristian Schwethelm; Daniel Rueckert; Georgios Kaissis

v3: substantially refined framing + minor corrections v2: added case studies on truncated-BPTT and hyperconnections


Reuses learned computation inside one model inference rather than repeating a full agent run. Scales looped code models through dense-to-loop initialization, recurrent pretraining, and post-training; the Findings of ACL 2026 paper reports a 40B-active/80B-total model trained on more than 12T code and general tokens.

Use LoopCoder: Scaling Code Intelligence via Looped Language Models to assess inner latent computation as a model capability inside a separately governed agent loop.

LoopCoder: Scaling Code Intelligence via Looped Language Models - ACL Anthology

Jian Yang, Wei Zhang, Shuyue Guo, Yizhi LI, Linzheng Chai, Zhengmao Ye, Shukai Liu, Yuyang Song, Jiajun Wu, Che Liu, Tianyu Zheng, Siwei Wu, Leo L, Xudong Ma, Chuan Hao, Ran Tao, Yan Xing, Jianzhou Wang, Mingjie Tang, Aishan Liu, Zhoujun Li, Xianglong Liu, Weifeng Lv, Bryan Dai. Findings of the Association for Computational Linguistics: ACL 2026. 2026.

Jian Yang; Wei Zhang; Shuyue Guo; Yizhi Li; Linzheng Chai; Zhengmao Ye; Shukai Liu; Yuyang Song; Jiajun Wu; Che Liu; Tianyu Zheng; Siwei Wu; Leo L; Xudong Ma; Chuan Hao; Ran Tao; Yan Xing; Jianzhou Wang; Mingjie Tang; Aishan Liu; Zhoujun Li; Xianglong Liu; Weifeng Lv; Bryan Dai


Looped World Models

Reuses learned computation inside one model inference rather than repeating a full agent run. Introduces LoopWM, which repeatedly refines action-conditioned latent environment states with a parameter-shared Transformer core, stability constraints, and adaptive early exit for long-horizon simulation.

Use Looped World Models to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2606.18208; inspect its method and evaluation before treating results as production evidence.

Current world models face a fundamental tension: faithful long-horizon simulation demands deep computation, but deeper models are expensive to deploy and prone to compounding errors. We resolve this by introducing Looped World Models (LoopWM), which are the first looped architectures for world modelling. Our method iteratively refines latent environment states through a parameter-shared transformer block. This yield up to 100x parameter efficiency over conventional approaches with adaptive computation that automatically scales depth to match the complexity of each prediction step. Orthogonal to scaling model size and training data, LoopWM establishes iterative latent depth as a new scaling axis for world simulation, which might significantly push the community forward.

Hongyuan Adam Lu; Z. L. Victor Wei; Qun Zhang; Jinrui Zeng; Bowen Cao; Lingwei Meng; Mocheng Li; Zezhong Wang; Haonan Yin; Naifu Xue; Minyu Chen; Cenyuan Zhang; Zefan Zhang; Hao Wei; Jiawei Zhou; Haoran Xu; Hao Yang; Ronglai Zuo; Tongda Xu; Yonghao Li; Jian Chen; Hebin Wang; Zeyu Gao; Yang Li; Wei Zhao; Qimin Zhong; Siqi Liu; Yumeng Zhang; Leyan Cui; Zhangyu Wang; Wai Lam


Reuses learned computation inside one model inference rather than repeating a full agent run. Introduces LOTUS, which loops over parallel latent thought blocks with intermediate supervision and reports explicit-chain-of-thought-level quality at 3B scale with lower thought-phase latency.

Use Bridging the Gap Between Latent and Explicit Reasoning with Looped Transformers to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2606.31779; inspect its method and evaluation before treating results as production evidence.

[2606.31779] Bridging the Gap Between Latent and Explicit Reasoning with Looped Transformers

Language models typically reason via explicit chain-of-thought (CoT), generating intermediate steps token-by-token. Latent CoT offers an alternative: it performs multi-step reasoning in the model's hidden states, replacing decoded tokens with continuous representations for greater efficiency. However, existing latent CoT methods underperform explicit CoT beyond 1B parameters, and the gap widens with scale. Looped, or recurrent-depth, Transformers, which reuse their weights to increase computation depth without adding parameters, are a natural fit for latent reasoning. We therefore ask whether looped Transformers can bridge this gap. We answer affirmatively with a simple recipe: a looped padded Transformer that processes K latent blocks in parallel for R iterations, with a cross-entropy loss on each latent position's gold CoT-step token, similar to explicit CoT supervision. We instantiate it as LOTUS (Looped Transformers with parallel supervision on latents). LOTUS is, to our knowledge, the first latent-CoT method to bridge the gap to explicit CoT at the 3B scale, while cutting thought-phase latency by 2.5x-6.9x from compact math expressions to natural language. Projecting LOTUS's post-loop latents through the base LM head recovers the gold reasoning steps and even surfaces alternative valid intermediate steps, evidence that its latent space is interpretable and CoT-aligned. Ablations confirm that both the looped backbone and the parallel supervision on gold CoT tokens are essential. Code is available at https://github.com/yingfan-bot/lotus.


Reuses learned computation inside one model inference rather than repeating a full agent run. Extends tied-depth recurrence beyond Transformers by repeatedly applying a shared state-space block and reshaping inputs across iterations, testing which loop principles transfer across model families.

Use Looped SSMs: Depth-Recurrence and Input Reshaping for Time Series Classification to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2605.16048; inspect its method and evaluation before treating results as production evidence.

[2605.16048] Looped SSMs: Depth-Recurrence and Input Reshaping for Time Series Classification

State Space Models (SSMs) are inherently recurrent along the sequence dimension, yet depth-recurrence - reusing the same block repeatedly across layers, as recently applied in looped transformers - has not been explored in this model family. We show that a looped SSM with $k$ parameters iterated $L$ times consistently closely matches or outperforms a standard SSM with $k \cdot L$ independent parameters across four architectures (LRU, S5, LinOSS, LrcSSM) and six time series classification benchmarks, despite operating within a strictly smaller hypothesis space, as we formally establish. Since the larger model contains the looped model as a special case, this dominance cannot be explained by expressivity and instead points to parameter sharing across depth as a beneficial inductive bias that simplifies optimization. These results demonstrate that depth-recurrence is orthogonal to sequence-recurrence and independently beneficial. We further show that input reshaping is an equally neglected design axis: concatenating timesteps for low-dimensional inputs, or flattening and rechunking the joint feature-time dimension for high-dimensional ones, yields accuracy gains of 1-6% across all models, confirmed over 5 random seeds. Both techniques provide standalone improvements that compound when combined, suggesting that depth and input reshaping are two independent and underexplored design axes for SSMs on time series.

Mónika Farsang; Ramin Hasani; Daniela Rus; Radu Grosu


Looped Diffusion Language Models

Reuses learned computation inside one model inference rather than repeating a full agent run. Applies selective shared-layer recurrence to masked diffusion language models so effective depth can scale during training and inference without adding parameters.

Use Looped Diffusion Language Models to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2605.26106; inspect its method and evaluation before treating results as production evidence.

[2605.26106] Looped Diffusion Language Models

Masked diffusion models (MDMs) have emerged as a promising alternative to autoregressive models for language modeling, yet the effective design of transformer architectures for MDMs remains underexplored. In this paper, we show that selectively looping the early-middle transformer layers significantly improves both training efficiency and model performance in MDMs. We call this approach LoopMDM(Looped Masked Diffusion Model), which brings two key benefits: looping layers at training-time yields a depth-scaling effect without adding parameters, while varying the number of loops at inference-time enables flexible compute scaling. Despite the simplicity, the results are striking: across multiple pre-training corpora, LoopMDM matches the performance of same-size MDMs with up to 3.3 fewer training FLOPs, while its final performance outperforms them on various reasoning benchmarks, including up to 8.5 points on GSM8K. It even surpasses deeper non-looped MDMs trained with comparable per-step compute, indicating that selective looping is more effective than naive depth scaling. Furthermore, LoopMDM can scale inference-time compute by increasing the number of loops. Adaptively adjusting the number of loops throughout the sampling process further yields additional gains in compute efficiency while maintaining performance. Lastly, with attention analysis, we provide evidence that looping is effective in MDMs by promoting interactions among masked positions. Our code and weights will be publicly released.

Sanghyun Lee; Chunsan Hong; Seungryong Kim; Jonghyun Lee; Jongho Park; Dongmin Park


Metis: Memory Foundation Model

Reuses learned computation inside one model inference rather than repeating a full agent run. Argues for native memory inside the backbone rather than bolted-on external modules: a persistent memory state compresses history, is read through memory attention, and is maintained gradient-free with forward passes only at inference. The model-level answer to problems the harness-level memory stacks keep patching.

Use Metis: Memory Foundation Model to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2607.26760; inspect its method and evaluation before treating results as production evidence.

[2607.26760] Metis: Memory Foundation Model

Recent advances in AI agents have increasingly internalized native capabilities into their underlying foundation models, giving rise to multimodal foundation models and large reasoning models. However, agent memory is still primarily implemented through external modules, leaving the native memory capability largely unexplored. In this paper, we take a first step toward this direction by introducing memory foundation models, which empower foundation models with native memory capabilities. We formalize native memory from two perspectives: a persistent and dynamically evolving memory state within the backbone, and native memory procedures that autonomously store and utilize information through model computation. We show that native memory offers advantages in architecture, end-to-end optimization, and efficiency. Based on this formulation, we propose Metis, the first prototype of memory foundation models. Metis introduces a new architecture that equips a foundation model with a native memory state, allowing historical information to be compressed into the model and accessed through memory attention. We construct large-scale memory-specific training data and introduce multiple optimization objectives to acquire these native memory procedures through mid-training. The online memory maintenance of Metis is gradient-free, and the memory update requires only a forward pass. At inference time, all learned model weights remain frozen, while the native memory states are autonomously transformed through standard forward computation. Through extensive experiments, we show that Metis exhibits native memory capabilities and further provide a detailed analysis of its strengths, limitations, and behaviors. To facilitate future research on memory foundation models, we release our project and model checkpoints.

Zeyu Zhang; Ziliang Guo; Yihang Sun; Xichong Zhang; Xixuan Hao; Zehao Lin; Yang Zhang; Xiaoyan Zhao; Tong Shen; Bo Tang; Zhi-Qin John Xu; Junchi Yan; Haofen Wang; Xu Chen; Feiyu Xiong; Zhiyu Li; Tat-Seng Chua


Reuses learned computation inside one model inference rather than repeating a full agent run. Attacks the memory problem one layer below retrieval: decoder-only models entangle long-term memory and reasoning in a single parameter set, so memory capacity cannot be scaled independently of the reasoning capacity you are paying for.

Use Memory Decoder at Scale: A Pretrained, Parametric Long-Term Memory to assess inner latent computation as a model capability inside a separately governed agent loop.

Research source arXiv:2607.27919; inspect its method and evaluation before treating results as production evidence.

[2607.27919] Memory Decoder at Scale: A Pretrained, Parametric Long-Term Memory

Decoder-only language models entangle long-term memory and reasoning in a single parameter set, making it difficult to scale memory capacity independently. Memory Decoder introduces a parametric long-term memory module but only studies it at a relatively small scale. In this work, we present Memory Decoder at Scale, scaling memory models up to 6.9B parameters and pretraining them on 300B tokens. At this data scale, the combined cost of indexing and search makes a standard Faiss pipeline infeasible. We address this bottleneck with a distributed pipeline for Faiss indexing and retrieval, together with sparse, batch-wise loading of kNN distributions. Across model scales, we find that allocating more parameters to memory yields a better parameter-performance tradeoff than scaling the base model alone. On 17 benchmarks, pairing a 6.9B general memory with Pythia-410M raises its average score from 29.86 to 37.34, surpassing Pythia-12B (37.24) with 39% fewer total parameters. For Qwen3 Base models ranging from 0.6B to 14B, 1.7B domain memories improve the average score across the three domains by more than 9 points at every scale. Overall, our results demonstrate that independently scaling pretrained memory offers a more parameter efficient path to improving language model performance.

Rubin Wei; Jiaqi Cao; Jiarui Wang; Junming Zhang; Qipeng Guo; Bowen Zhou; Zhouhan Lin


Discovery Loop

Distills reusable agent-control patterns that are not tied to a single vendor implementation. Company thesis for automating the experimental loop itself: propose, implement, run, examine, iterate, driven by frontier models over large-scale compute so thousands of experiments run in parallel instead of sequentially by hand. Starts with machine learning research and uses its own stack as the first customer. A statement of direction rather than a shipped system.

Use Discovery Loop to turn a recurring-agent idea into an explicit loop contract.

Working implementation, framework, runtime, or repository; signal comes from usable code and ecosystem adoption.

Specify a loop contract and operating pattern.

Discovery Loop is building AI systems that automate the experimental loops of science and engineering. Continuous Exploration.


Building Effective Agents

Orchestration and control flow are made explicit and inspectable. Anthropic's canonical guide to workflows and agents, including evaluator-optimizer and orchestrator-workers patterns.

Use Building Effective Agents to turn a recurring-agent idea into an explicit loop contract.

Primary documentation from a platform, SDK, standard, or framework; strong implementation signal.

Building Effective AI Agents \ Anthropic

Discover how Anthropic approaches the development of reliable AI agents. Learn about our research on agent capabilities, safety considerations, and technical framework for building trustworthy AI.


Distills reusable agent-control patterns that are not tied to a single vendor implementation. Decomposes the harness layer that loops build on into control, agency, and runtime, audits 63 harness works, and proposes a HarnessCard so reported agent gains can be separated from harness effects.

Use Harness Engineering for Language Agents: The Harness Layer as Control, Agency, and Runtime to turn a recurring-agent idea into an explicit loop contract.

Research source; inspect its method and evaluation before treating results as production evidence.

Chaoyue He; Xin Zhou; Di Wang; Hong Xu; Wei Liu; Chunyan Miao

Version 2; the primary source states that this preprint is not peer-reviewed.


Persistent memory is treated as an external runtime artifact. Detailed orchestrator-worker system with planning, memory, subagents, citation passes, and iterative research loops.

Use How we built our multi-agent research system to turn a recurring-agent idea into an explicit loop contract.

Contextual source from www.anthropic.com; useful for practice signals or boundary conditions, not independent validation.

How we built our multi-agent research system \ Anthropic

On the the engineering challenges and lessons learned from building Claude's Research system


Distills reusable agent-control patterns that are not tied to a single vendor implementation. PDF overview of agent architecture patterns, including generator-evaluator loops.

Use Building Effective AI Agents: Architecture Patterns and Implementation Frameworks to turn a recurring-agent idea into an explicit loop contract.

Date verified from the primary PDF creation metadata.


AI Agent Architectures

Persistent memory is treated as an external runtime artifact. System-design overview of ReAct, reflection, planning, tool use, memory, and control strategies.

Use AI Agent Architectures to turn a recurring-agent idea into an explicit loop contract.

Contextual source from hld.handbook.academy; useful for practice signals or boundary conditions, not independent validation.

AI Agent Architectures (ReAct, Reflection, Planning, Tool Use, Memory) - The HLD Handbook

The canonical patterns for turning an LLM into an agent: ReAct's think-act-observe loop, reflection and self-critique, planner-executor decomposition, tool use and function calling, and how agents manage short- and long-term memory.


What Are Agentic Workflows?

Persistent memory is treated as an external runtime artifact. Accessible taxonomy of planning, tool use, reflection, and memory patterns.

Use What Are Agentic Workflows? to turn a recurring-agent idea into an explicit loop contract.

Contextual source from weaviate.io; useful for practice signals or boundary conditions, not independent validation.

What Are Agentic Workflows? Patterns, Memory, Use Cases, and Examples | Weaviate

Agentic workflows combine AI agents, tools, and agent memory to create adaptive systems. Learn the core patterns, use cases, and real-world examples.


Agent Planning & Reflection Patterns

Distills reusable agent-control patterns that are not tied to a single vendor implementation. Visual explanation of plan-execute, observe, reflect, retry, and stop patterns.

Use Agent Planning & Reflection Patterns to turn a recurring-agent idea into an explicit loop contract.

Contextual source from learnaivisually.com; useful for practice signals or boundary conditions, not independent validation.

Agent Planning & Reflection Patterns | Learn AI Visually LAV LAV

When agents should plan, retry, pause, or stop. Reasoning budget, ReAct, Reflexion, and termination logic — each tied to a 'when' decision.


Agentic Design Patterns

Distills reusable agent-control patterns that are not tied to a single vendor implementation. Practical overview of ReAct, reflection, tool use, planning, and how to combine them in real-world agents.

Use Agentic Design Patterns to turn a recurring-agent idea into an explicit loop contract.

Contextual source from addyosmani.com; useful for practice signals or boundary conditions, not independent validation.

AddyOsmani.com - Lesson 4: agentic design patterns

Addy Osmani is an engineering and evangelism leader who spent over 14 years at Google leading developer experience across Chrome and, in recent years, AI (Gemini, coding agents, and agentic engineering), most recently as a Director at Google Cloud AI.


12 Factor Agents

State persistence is explicit enough for repeated runs and handoff. Operating principles for production agents, including explicit prompts, state ownership, and pause-resume behavior.

Use 12 Factor Agents to turn a recurring-agent idea into an explicit loop contract.

Inspectable GitHub source (25,110 stars; 1,905 forks; NOASSERTION license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - humanlayer/12-factor-agents: What are the principles we can use to build LLM-powered software that is actually good enough to put in the hands of production customers? · GitHub

What are the principles we can use to build LLM-powered software that is actually good enough to put in the hands of production customers? - humanlayer/12-factor-agents


Durable Execution for Agentic Workflows

Durable execution and replay are treated as first-class loop infrastructure. Explains checkpointing, event-sourced journals, replay, and recovery for long-running agent workflows.

Use Durable Execution for Agentic Workflows to turn a recurring-agent idea into an explicit loop contract.

Operational pattern or playbook; signal comes from reusable loop structure and practical transferability.

Durable Execution for Agentic Workflows | Arizen

A while loop is at-most-once across process boundaries. Production agents need exactly-once. The architecture must encode the guarantee.


Control flow is represented as an inspectable graph rather than an opaque prompt loop. Proposes Loop-Graph, a long-horizon agent framework that couples iterative refinement loops with graph-structured persistent memory; the supplied manuscript screenshot reports evaluation on 9,842 real-world tasks, success gains up to 38.6 percentage points, correctness gains up to 27.4 percentage points, fewer redundant tool calls, and lower latency versus strong prompting and RAG baselines.

Use Loop Engineering Meets Graph Engineering to turn a recurring-agent idea into an explicit loop contract.

Lingjiao Chen; Matei Zaharia; Jack Clark; Christopher Re; Chelsea Finn; Ion Stoica

Author list transcribed from the manuscript screenshot supplied with the gallery reference; kept in code so audit regeneration preserves it.


Code as Agent Harness

The work separates roles across agents, verifiers, or orchestration layers. Organizes agent infrastructure into harness interface, feedback-driven control, and multi-agent scaling for executable, verifiable, stateful systems; maps the harness layer that loops build on.

Use Code as Agent Harness to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2605.18747; inspect its method and evaluation before treating results as production evidence.

Recent large language models (LLMs) have demonstrated strong capabilities in understanding and generating code, from competitive programming to repository-level software engineering. In emerging agentic systems, code is no longer only a target output. It increasingly serves as an operational substrate for agent reasoning, acting, environment modeling, and execution-based verification. We frame this shift through the lens of agent harnesses and introduce code as agent harness: a unified view that centers code as the basis for agent infrastructure. To systematically study this perspective, we organize the survey around three connected layers. First, we study the harness interface, where code connects agents to reasoning, action, and environment modeling. Second, we examine harness mechanisms: planning, memory, and tool use for long-horizon execution, together with feedback-driven control and optimization that make harness reliable and adaptive. Third, we discuss scaling the harness from single-agent systems to multi-agent settings, where shared code artifacts support multi-agent coordination, review, and verification. Across these layers, we summarize representative methods and practical applications of code as agent harness, spanning coding assistants, GUI/OS automation, embodied agents, scientific discovery, personalization and recommendation, DevOps, and enterprise workflows. We further outline open challenges for harness engineering, including evaluation beyond final task success, verification under incomplete feedback, regression-free harness improvement, consistent shared state across multiple agents, human oversight for safety-critical actions, and extensions to multimodal environments. By centering code as the harness of agentic AI, this survey provides a unified roadmap toward executable, verifiable, and stateful AI agent systems.

Xuying Ning; Katherine Tieu; Dongqi Fu; Tianxin Wei; Zihao Li; Yuanchen Bei; Jiaru Zou; Mengting Ai; Zhining Liu; Ting-Wei Li; Lingjie Chen; Yanjun Zhao; Ke Yang; Bingxuan Li; Cheng Qian; Gaotang Li; Xiao Lin; Zhichen Zeng; Ruizhong Qiu; Sirui Chen; Yifan Sun; Xiyuan Yang; Ruida Wang; Rui Pan; Chenyuan Yang; Dylan Zhang; Liri Fang; Zikun Cui; Yang Cao; Pan Chen; Dorothy Sun; Ren Chen; Mahesh Srinivasan; Nipun Mathur; Yinglong Xia; Hong Li; Hong Yan; Pan Lu; Lingming Zhang; Tong Zhang; Hanghang Tong; Jingrui He


Verification is promoted from a final check to a loop-control signal. Proposes a task-level SCOPE-V loop (Specify, Constrain, Orchestrate, Prove, Evolve, Verify) with human approval gates, arguing agentic coding needs process control and independent verification, not better prompts.

Use Agentic Agile-V: From Vibe Coding to Verified Engineering to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2605.20456; inspect its method and evaluation before treating results as production evidence.

[2605.20456] Agentic Agile-V: From Vibe Coding to Verified Engineering in Software and Hardware Development

Agentic AI coding systems can inspect repositories, plan implementation steps, edit files, call tools, run tests, and submit pull requests. These capabilities make software and hardware development faster in some settings, but current evidence does not support the simple claim that autonomous code generation automatically improves engineering outcomes. Controlled studies report productivity gains in some enterprise tasks, slowdowns in mature open-source work, moderate but heterogeneous meta-analytic effects, and persistent failures in repository setup, dependency handling, permission gating, and hardware verification. This paper argues that the central problem is no longer prompt engineering; it is engineering process control. It synthesizes evidence from agentic software engineering, GitHub-scale adoption studies, repository-level agent configuration, productivity trials, issue-resolution benchmarks, and hardware/RTL verification research. It proposes Agentic Agile-V, a process framework that uses Agile-V as the lifecycle backbone and a task-level SCOPE-V loop - Specify, Constrain, Orchestrate, Prove, Evolve, and Verify - to convert conversational intent into structured engineering artifacts and acceptance evidence. The paper contributes: (i) a taxonomy of minimum input artifacts for agentic software, firmware, and hardware work; (ii) a conversation-to-contract gate that separates exploratory dialogue from implementation; (iii) risk-adaptive feature, bug-fix, testing, and hardware workflows; and (iv) an evidence-bundle acceptance model for agent-generated artifacts. The paper concludes that agentic AI does not eliminate engineering discipline; it increases the value of requirements, constraints, traceability, independent verification, and human approval.


Orchestration and control flow are made explicit and inspectable. Splits agentic SE into an Agent Command Environment for human orchestration and an Agent Execution Environment for agent task execution, a research roadmap for the layers recurring loops run inside.

Use Agentic Software Engineering: Foundational Pillars and a Research Roadmap to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2509.06216; inspect its method and evaluation before treating results as production evidence.

[2509.06216] Agentic Software Engineering: Foundational Pillars and a Research Roadmap

Agentic Software Engineering (SE 3.0) represents a new era where intelligent agents are tasked not with simple code generation, but with achieving complex, goal-oriented SE objectives. To harness these new capabilities while ensuring trustworthiness, we must recognize a fundamental duality within the SE field in the Agentic SE era, comprising two symbiotic modalities: SE for Humans and SE for Agents. This duality demands a radical reimagining of the foundational pillars of SE (actors, processes, tools, and artifacts) which manifest differently across each modality. We propose two purpose-built workbenches to support this vision. The Agent Command Environment (ACE) serves as a command center where humans orchestrate and mentor agent teams, handling outputs such as Merge-Readiness Packs (MRPs) and Consultation Request Packs (CRPs). The Agent Execution Environment (AEE) is a digital workspace where agents perform tasks while invoking human expertise when facing ambiguity or complex trade-offs. This bi-directional partnership, which supports agent-initiated human callbacks and handovers, gives rise to new, structured engineering activities (i.e., processes) that redefine human-AI collaboration, elevating the practice from agentic coding to true agentic software engineering. This paper presents the Structured Agentic Software Engineering (SASE) vision, outlining several of the foundational pillars for the future of SE. The paper culminates in a research roadmap that identifies a few key challenges and opportunities while briefly discussing the resulting impact of this future on SE education. Our goal is not to offer a definitive solution, but to provide a conceptual scaffold with structured vocabulary to catalyze a community-wide dialogue, pushing the SE community to think beyond its classic, human-centric tenets toward a disciplined, scalable, and trustworthy agentic future.

Ahmed E. Hassan; Hao Li; Dayi Lin; Bram Adams; Tse-Hsun Chen; Yutaro Kashiwa; Dong Qiu


The Art of Loop Engineering

Verification is promoted from a final check to a loop-control signal. LangChain's account of four stacked loops around agents (core execution, rubric-based verification, event-driven triggers, and trace-driven self-improvement) using a documentation-writing agent as the running example.

Use The Art of Loop Engineering to turn a recurring-agent idea into an explicit loop contract.

Contextual source from www.langchain.com; useful for practice signals or boundary conditions, not independent validation.

Agents automate real-world work, but reliable performance requires more than a good model, it requires a carefully designed harness built for specific tasks. This post explores the core agent loop, how stacking and extending loops builds more effective agents, and how to instrument each level with LangChain primitives.


Loopy

Verification is promoted from a final check to a loop-control signal. Library of reusable AI-agent loops with verification checks and stopping conditions, plus an installable skill for finding, adapting, and designing repeatable agent workflows.

Use Loopy to turn a recurring-agent idea into an explicit loop contract.

Inspectable GitHub source (2,981 stars; 268 forks; MIT license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - Forward-Future/loopy: A library of practical AI-agent loops and an installable skill for finding, adapting, and designing repeatable agent workflows. · GitHub

A library of practical AI-agent loops and an installable skill for finding, adapting, and designing repeatable agent workflows. - Forward-Future/loopy


Verification is promoted from a final check to a loop-control signal. Addy Osmani's February 2026 essay recasting engineers as operators of parallel agent workstreams, with agents running "thirty minutes, an hour, several hours and increasingly days" and verification, not generation, as the new bottleneck; the fleet-level framing that precedes his June Loop Engineering essay.

Use The Factory Model: How Coding Agents Changed Software Engineering to turn a recurring-agent idea into an explicit loop contract.

AddyOsmani.com - The Factory Model: How Coding Agents Changed Software Engineering

Software engineering is not about writing code anymore. It is about building the factory that builds your software.


2026 Agentic Coding Trends Report

Primary-source operational guidance rather than commentary. Anthropic's official 2026 trends report on the shift from single coding assistants to coordinated agent teams running autonomously for hours or days, with case studies from Rakuten, TELUS, and Zapier (landing page is registration-gated; the direct PDF is public).

Use 2026 Agentic Coding Trends Report to turn a recurring-agent idea into an explicit loop contract.

How coding agents are transforming software development - and what it means for engineering teams in 2026. Insights on multi-agent systems, human-AI collaboration, and scaling agentic coding across organizations. Includes case studies from Rakuten, TELUS, Zapier, and more.


HomeRail

Control flow is represented as an inspectable graph rather than an opaque prompt loop. TypeScript runtime that turns one-off agent chats into auditable, reusable DAG workflows on self-hosted hardware, with a DAG engine, CLI, and voice front end.

Use HomeRail to turn a recurring-agent idea into an explicit loop contract.

Inspectable GitHub source (855 stars; 183 forks; MIT license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - xiaotianfotos/homerail: Voice-first local agent orchestration runtime for auditable DAG workflows. · GitHub

Voice-first local agent orchestration runtime for auditable DAG workflows. - xiaotianfotos/homerail


Verification is promoted from a final check to a loop-control signal. Terence Tao's July 11, 2026 account of porting roughly two dozen Java 1.0 applets to JavaScript and resurrecting long-abandoned projects through iterative agent sessions, concluding that domain expertise remains the human verification layer: high-level design decisions stay with the author while implementation is automated away, and the exchange was "a net wash" on code quality, he caught one minor bug in the agent's output while the agent found two bugs in his original code.

Use Old and New Apps, via Modern Coding Agents to turn a recurring-agent idea into an explicit loop contract.

Contextual source from terrytao.wordpress.com; useful for practice signals or boundary conditions, not independent validation.

Old and new apps, via modern coding agents | What's new

I have been interested in machine-assisted ways to do and teach mathematics from as far back as 1999, when I started coding several applets in Java 1.0, both for my complex analysis and linear alge…


Distills reusable agent-control patterns that are not tied to a single vendor implementation. Introduces a behavior-centered source map and behavior-guided program decomposition for evolving harnesses, improving behavior localization and edit planning on two agent harnesses while reducing planner token use.

Use Harness Handbook: Making Evolving Agent Harnesses Readable,Navigable, and Editable to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2607.13285; inspect its method and evaluation before treating results as production evidence.

[2607.13285] Harness Handbook: Making Evolving Agent Harnesses Readable,Navigable, and Editable

The capability of a modern AI agent depends not only on its foundation model but also on its harness, which constructs prompts, manages state, invokes tools, and coordinates execution. As models, APIs, environments, and requirements evolve, the harness must be continually modified. Before such a change can be made, a developer or coding agent must identify all code locations that implement the target behavior. This is difficult because production harnesses are large, tightly coupled, and behaviorally distributed, while modification requests describe what the system should do and repositories are organized by files and modules. Code search, repository indexing, and long-context processing ease inspection, but still leave this behavior-to-code mapping to be recovered by hand. Behavior localization is therefore a central bottleneck in harness evolution. We introduce the Harness Handbook, a behavior-centric representation synthesized automatically from a harness codebase via static analysis and LLM-assisted structuring, linking each behavior to its corresponding source. We also introduce Behavior-Guided Progressive Disclosure (BGPD), which guides agents from high-level behaviors to relevant implementation details and verifies candidate locations against the current source. On diverse modification requests from two open-source harnesses, Handbook-Assisted planning improves behavior localization and edit-plan quality while using fewer planner tokens, with the largest gains on scattered sites, rarely executed paths, and cross-module interactions. Evolving complex agentic systems thus depends not only on generating edits, but also on determining where those edits should be made.

Ruhan Wang; Yucheng Shi; Zongxia Li; Zhongzhi Li; Yue Yu; Junyao Yang; Kishan Panaganti; Haitao Mi; Dongruo Zhou; Leoweiliang

29 pages, 6 figures. Project page: https://ruhan-wang.github.io/Harness-Handbook/


Persistent memory is treated as an external runtime artifact. Lets an agent adapt six harness dimensions per case using a dual-layer experience memory; results improve over fixed harnesses, while broad robustness and the contribution of each adaptive component remain open questions.

Use MemoHarness: Agent Harnesses That Learn from Experience to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2607.14159; inspect its method and evaluation before treating results as production evidence.

[2607.14159] MemoHarness: Agent Harnesses That Learn from Experience

An agent harness is the external control layer that turns a base LLM into an executable agent by managing context, tools, orchestration, memory, decoding, and output handling. While harness design strongly affects agent behavior, most automatic improvement methods optimize narrower artifacts such as prompts, pipelines, or workflows, and deployed agents usually reuse a single global harness for all cases. We introduce MemoHarness, an adaptive harness optimization framework that learns from its own executions. MemoHarness decomposes the harness into six editable control dimensions, stores per-case diagnoses and distilled global patterns in a dual-layer experience bank, and adapts the learned harness to each test case using retrieved experience without test-time labels, feedback, or additional search. In our evaluation across shell-agent, code-generation, and analytical-reasoning benchmarks, MemoHarness improves over the fixed harnesses we compare against and shows selective transfer to unseen suites and base models. Its additional context can also remain cost-competitive when much of the retrieved experience is cacheable. These results provide evidence that execution experience is a practical substrate for building agent harnesses that are more adaptive than a single static configuration, while leaving broader claims about statistical robustness and component attribution to future work.

Yue Huang; Wenjie Wang; Han Bao; Yuchen Ma; Xiaonan Luo; Yi Nian; Haomin Zhuang; Zheyuan Liu; Yue Zhao; Xiangliang Zhang


Recursive Harness Self-Improvement

Context is managed as durable loop state rather than a single prompt payload. Represents an agent loop as a prompt-level harness specification and iteratively revises it from pairwise feedback over its own history; across 30 synthetic machine-learning research tasks, a few revisions lift low-reasoning agents above the corresponding maximum-reasoning setting while cutting inference cost by up to 60%, primarily through better context flow between agents.

Use Recursive Harness Self-Improvement to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2607.15524; inspect its method and evaluation before treating results as production evidence.

[2607.15524] Recursive Harness Self-Improvement

Under model--harness co-evolution, harnesses are not merely inference-time scaffolds but data-generating components whose execution traces can shape future foundation models. This motivates harness-in-the-loop learning: optimizing harnesses for both immediate agent performance and the quality of traces used for future model training. However, continually updating provider-built scaffolds is costly and labor-intensive. We therefore investigate whether optimizing user-constructed harnesses in a task-specific manner can improve execution-trace quality while remaining computationally lightweight and requiring only a few update iterations. To this end, we introduce Recursive Harness Self-Improvement (RHI), which represents the harness as a prompt-level specification of the agent loop and iteratively refines it using pairwise feedback over its own revision history. Across 30 synthetic machine-learning research tasks spanning quantitative finance, robotics, and pharmacy, a few RHI iterations suffice to substantially raise the performance ceiling of low-reasoning-effort agents, exceeding the corresponding maximum-reasoning-effort setting while reducing inference cost by up to 60%. We show that these gains arise primarily from improved task-specific context management through more effective inter-agent information flow rather than longer reasoning traces. Finally, we formalize this behavior as an information-theoretic hypothesis for RHI's implicit optimization objective, suggesting RHI as a practical algorithm for continual learning within the paradigm of model--harness co-evolution.

Hyunin Lee; Jinglue Xu; Jeffrey Seely; Donghyun Lee; Matei Zaharia; Yujin Tang

This work addresses the first half of the model-harness coevolution loop


Packages the evidence as queryable CSV and JSONL rather than only a rendered page. Filters roughly 821,000 crawled agent skills into a 96,401-item corpus with a 16-class taxonomy and utility, robustness, and safety facets; evaluations across three benchmarks, two harnesses, and two open models report gains up to 7.5 percentage points while exposing both coverage and harness boundaries. The announced dataset, models, and code are pending release.

Use SkillCorpus: Consolidating and Evaluating the Open Skill Ecosystem for Real-World LLM Agents to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2607.15557; inspect its method and evaluation before treating results as production evidence.

[2607.15557] SkillCorpus: Consolidating and Evaluating the Open Skill Ecosystem for Real-World LLM Agents

Agent skills, SKILL files that package reusable procedural knowledge for an LLM agent, are a popular mechanism for extending agent capabilities. Public repositories now host them in large and growing numbers, yet these artifacts are fragmented, redundant, and uneven in quality, and their value in practice is unclear. A core question remains open, namely how to consolidate this open-source SKILL ecosystem into a single usable corpus, and what bounds its benefit on real-world agent tasks. We present SkillCorpus, a framework that aggregates, curates, matches, and evaluates the open skill ecosystem at scale. It filters ~821,000 crawled skills through a multi-stage pipeline into 96,401 skills organised by a 16-class taxonomy and three quality facets (utility, robustness, safety), and pairs them with a fine-tuned retrieval-and-selection stack that matches task-relevant skills. We evaluate end-to-end across three benchmarks (SkillsBench, GDPVal, QwenClawBench), two harnesses, and two open backbones with a frontier robustness check. Integrating SkillCorpus yields consistent gains across all three benchmarks, largest on SkillsBench (+7.5 pp). An operational analysis traces the gains to a coverage boundary and a harness boundary. SkillCorpus is, to our knowledge, the first end-to-end account of when a curated, retrieval-served community corpus improves real agent tasks, and where it does not. The dataset, models, and code will be released upon acceptance.

Yanze Wang; Pengfei Yao; Tianyi Sun; Chuanrui Hu; Yan Xiao; Xiaotian Luo; Yunyun Han; Yifan Chen; Jun Sun; Yafeng Deng


Evaluation data is used as the feedback signal for improving loop behavior. Compares a fixed extraction workflow with reflective variants under one evaluation harness, measuring tool execution, retries, reflection, memory use, runtime, and recovery so agentic mechanisms can be judged by observable process changes rather than output scores alone.

Use Behavioral Controllability of Agentic Models for Information Extraction: From Fixed Workflows to Reflective Agents to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2607.15715; inspect its method and evaluation before treating results as production evidence.

[2607.15715] Behavioral Controllability of Agentic Models for Information Extraction: From Fixed Workflows to Reflective Agents

Large language model (LLM) agents are increasingly used for complex information-extraction tasks, yet it remains unclear whether agentic components such as reflection and memory lead to observable and controllable improvements over fixed LLM workflows. We study this question through conference-paper dataset extraction, where a system must identify datasets mentioned in scholarly PDFs and produce structured records. We compare a fixed workflow baseline with reflective agent variants and specify an optimized agent condition (S2) that extends the same task with richer PDF tools and dynamic tool selection. Our evaluation emphasizes process-level behavior--including tool execution, retries, reflection, memory use, runtime, and failure recovery--while treating extraction coverage and field completeness as secondary outcome measures. The paper characterizes when agentic mechanisms change system behavior, whether these changes improve task completion, and how the observed failure modes motivate an optimized agent design under the same evaluation harness.

Lujia Zhang; Xingzhou Chen; Hongwei Feng


Durable execution and replay are treated as first-class loop infrastructure. Manually analyzes 255 issue reports from Codex, Gemini CLI, LangChain, and CrewAI to classify bugs triggered by an interaction between model output and harness behavior; silent failures, weak test oracles, and stochastic reproduction motivate dedicated replay and fault-localization support.

Use Understanding Agent-Reactive Bugs at the Model-Harness Boundary: An Empirical Study of LLM Agent Issue Reports to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2607.15684; inspect its method and evaluation before treating results as production evidence.

[2607.15684] Understanding Agent-Reactive Bugs at the Model-Harness Boundary: An Empirical Study of LLM Agent Issue Reports

LLM agents span command-line interfaces (e.g., Codex) and agent frameworks (e.g., LangChain), integrating backend LLMs with harness code that parses model outputs, controls agent loops, and manages context. Both the harness and LLM-generated responses jointly shape an agent's execution. This architecture gives rise to bugs that cannot be readily understood by inspecting either component alone, because some bugs occur only when a particular LLM response elicits an abnormal reaction from the agent. Prior empirical studies of agent bugs have largely attributed failures either to limited model capabilities or to harness-side defects, such as outdated APIs and configuration misalignment, without characterizing these AR bugs. We conduct the first empirical study focused on agent-reactive (AR) bugs. Through manual analysis of 255 bug reports from Codex, Gemini-CLI, LangChain, and CrewAI, we construct a two-axis taxonomy covering observable symptoms and the LLM behaviors that trigger them. Our findings show that many AR bugs manifest as silent errors without well-defined test oracles, which makes detection difficult. The stochasticity of LLM responses further complicates bug reproduction. We additionally examine fixes proposed by users and implemented by developers. This analysis exposes a mismatch: users frequently advocate harness-side guardrails, whereas developers may attribute the issue to the LLM or respond slowly to user-proposed fixes. These findings point to the need for mechanisms that help users and developers understand the root causes and resolutions of AR bugs. Overall, the study highlights challenges specific to LLM agents and motivates the design of test oracles, reproduction support, and fault-localization techniques for AR bugs.

Jingyi Chen; Songqiang Chen; Hengcheng Zhu; Jialun Cao; Jiasi Shen; Shing-Chi Cheung


Control flow is represented as an inspectable graph rather than an opaque prompt loop. Organizes long-running scientific work around goal-scoped review gates, domain translators, an agent runtime and workflow engine, and an evidence DAG that links claims to provenance; eight end-to-end cases include multi-day research sprints, while deeper team collaboration remains planned work.

Use SciForge: An AI-Native, Multimodal Workbench for Scientific Discovery to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2607.16038; inspect its method and evaluation before treating results as production evidence.

[2607.16038] SciForge: An AI-Native, Multimodal Workbench for Scientific Discovery

Scientific work increasingly spans heterogeneous artifacts -- papers, code, datasets, scientific file formats, model outputs, figures, manuscripts, and team decisions -- yet general-purpose AI assistants rarely preserve these objects as a coherent, auditable research state. We present SciForge, a multimodal research-native AI workbench that reserves the graphical interface for human judgment while search, parsing, model routing, workflow execution, plotting, writing, and presentation generation run as modular agent-accessible services. SciForge is built around five pillars: (i) \emph{goal-scoped scientific decision governance} for \textbf{goal-oriented} research, with review gates and shared review surfaces; (ii) \emph{translate-then-reason} for \textbf{multimodal} input, routing scientific objects through domain translators before the agent reasons; (iii) \emph{evidence governance} for \textbf{auditable} traceability, linking claims to provenance chains and audit findings; (iv) \emph{collaborative team science} for \textbf{collaborative} research, enabling multi-role decision governance, with shared team workspaces planned for future releases; and (v) \emph{real-world application scenarios} for \textbf{practical} impact, demonstrated through eight end-to-end user cases, with flagship demonstrations including multi-day agentic research sprints for gene discovery, AI-guided de novo protein design, molecular optimization, and genome-to-BGC discovery. The system combines a thin interaction layer, contextual research capability patterns, an Agent Runtime and Workflow Engine, an Evidence-DAG audit sidecar and a Scientific Model Router. SciForge currently runs as a desktop application, with mobile supervision support; future releases will deepen team collaboration. The system is open-source and available at https://github.com/AGI4Sci/SciForge

SciForge Team; Zhangyang Gao; Minghao Fang; Yifei Liu; Hanhui Yang; Xinyu Gu; Shixiang Tang; Siqi Sun; Lei Bai; Cheng Tan; Mengdi Liu; Hao Wu; Shuizhou Chen


Verification is promoted from a final check to a loop-control signal. Argues the coding-agent bottleneck has shifted from generation to three infrastructure problems: interfaces for parallel agent fleets, a coding-optimized inference stack with prefix caching, and verification layers built on formal proofs and trace diffing.

Use Coding Agents 2.0: Interface, Inference, and Verification to turn a recurring-agent idea into an explicit loop contract.

Contextual source from www.gradient.com; useful for practice signals or boundary conditions, not independent validation.

Coding Agents 2.0: Interface, Inference, and Verification | Gradient Ventures The coding agent stack — Market map

In under a year, writing software became the biggest thing people do with large language models. The revenue followed the tokens: Cursor reached about $4B in annualized revenue in under four years and recently agreed to a $60B all-stock acquisition by SpaceX, and Claude Code crossed a $1B run-rate within six months of launch. Every developer we talk to has a "that demo blew my mind" story. We think the first wave is basically settled. The model can write the code. The interesting question for the next few years isn't whether agents can generate code, it's everything that happens around the model: how we run agents at scale, how we serve them when compute is scarce, and how we trust what they ship. That is where we are spending our time at Gradient, and where we think the next set of category-defining companies gets built. As coding adoption deepens, the bottleneck stops being model capability and becomes two things in short supply: human attention and compute. A coder's focus drifts in the minutes an agent takes to finish, and no human can review the volume of code a fleet of agents produces. Compute is the other wall, and coding hits it first because it is the most token-hungry workload on the network.


Towards a Harness That Can Do Anything

Verification is promoted from a final check to a loop-control signal. Essay on designing a general-purpose agent harness, examining what capability boundaries, tool surfaces, and verification hooks a do-anything harness actually requires.

Use Towards a Harness That Can Do Anything to turn a recurring-agent idea into an explicit loop contract.

Contextual source from eardatasci.github.io; useful for practice signals or boundary conditions, not independent validation.


Verification is promoted from a final check to a loop-control signal. NVIDIA's model-agnostic framework (NOOA) where an agent is a Python object: methods are actions, fields are state, docstrings are prompts, and type annotations are contracts; a method body of '...' is completed at runtime by an LLM-driven agent loop while normal bodies stay deterministic, letting agent behavior be tested and refactored like ordinary software. Evaluated on SWE-bench Verified and ARC-AGI-3.

Use NVIDIA-labs OO Agents: Native Python Object-Oriented Agents to turn a recurring-agent idea into an explicit loop contract.

Research source arXiv:2607.20709; inspect its method and evaluation before treating results as production evidence.

[2607.20709] NVIDIA-labs OO Agents: Native Python Object-Oriented Agents

Traditional agent development is split across prompt templates, tool schemas, callback code, and workflow graphs. We present NVIDIA Object-Oriented Agents (NOOA), a model-agnostic Python framework for building reliable AI agents. NOOA takes a simpler approach: an agent is a Python object. Its methods are the actions the model can take, fields are its state, docstrings are its prompts, and its type annotations are contracts. A method whose code body consists of "..." is completed at runtime by an LLM-driven agent loop, while methods with normal bodies remain standard deterministic Python. This gives developers and agents the same interface, so agent behavior can be tested, traced, refactored, and improved just like other software. This paper makes three contributions. (1) We present the agent-as-a-Python-object programming model and the design principles behind it. Where Python has existing abstractions, we adopt them directly. Agent-specific capabilities--context, events, state rendering, long-term memory, and validated LLM loops--are exposed through simple Pythonic APIs, so both developers and agents share one familiar programming model. (2) We identify six model-facing ideas that NOOA is, to our knowledge, the first to combine on a single surface: typed input/output, pass-by-reference over live objects, code as action, programmable loop engineering, explicit object state, and model-callable harness APIs for context and events. We find the community already converging on several of these ideas--often as experimental or partial features--and present the comparison to encourage further adoption. (3) We demonstrate that current models use this interface effectively, both in targeted capability tests and on agentic and reasoning benchmarks such as SWE-bench Verified and Terminal-Bench 2.0 and ARC-AGI-3.

Paul Furgale; Severin Klingler; James Nolan; Matt Staats; Gaia Di Lorenzo; Elisa Martinez Abad; Christian Schüller; Razvan Dinu; Alessio Devoto; Pascal Berard; Gal Kaplun; Elad Sarafian; Riccardo Roveri; Leon Derczynski; Ricardo Silveira Cabral