diff --git "a/data/resources.csv" "b/data/resources.csv" --- "a/data/resources.csv" +++ "b/data/resources.csv" @@ -106,18 +106,18 @@ ale-0104,Official Runtime Guides,official-runtime-guides,Docs,πŸ“š,"Cursor 3.11: ale-0105,Official Runtime Guides,official-runtime-guides,Docs,πŸ“š,Jules,https://jules.google/docs,external,jules.google,"Google's asynchronous coding agent that plans, executes tasks in isolated cloud VMs, and returns reviewable diffs.","Google's asynchronous coding agent that plans, executes tasks in isolated cloud VMs, and returns reviewable diffs.","Google's asynchronous coding agent that plans, executes tasks in isolated cloud VMs, and returns reviewable diffs.","Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Google's asynchronous coding agent that plans, executes tasks in isolated cloud VMs, and returns reviewable diffs.",Use Jules to choose an implementation surface for repeatable agent work.,Primary official documentation from jules.google; use it for current product or standard behavior.,high,README.md,654,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L654,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;context;delegation;state,builder,official-documentation,ok,https://jules.google/docs,Getting started | Jules,Set up and run your first task with Jules,,,,,Jules,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0106,Official Runtime Guides,official-runtime-guides,Docs,πŸ“š,Devin Docs,https://docs.devin.ai/get-started/devin-intro,external,docs.devin.ai,"Documentation for a long-running autonomous software engineer with sessions, playbooks, knowledge, and review boundaries.","Documentation for a long-running autonomous software engineer with sessions, playbooks, knowledge, and review boundaries.","Documentation for a long-running autonomous software engineer with sessions, playbooks, knowledge, and review boundaries.","Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Documentation for a long-running autonomous software engineer with sessions, playbooks, knowledge, and review boundaries.",Use Devin Docs to choose an implementation surface for repeatable agent work.,Primary official documentation from docs.devin.ai; use it for current product or standard behavior.,high,README.md,655,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L655,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;context;delegation;state,builder,official-documentation,ok,https://docs.devin.ai/get-started/devin-intro,Introducing Devin - Devin Docs,"Devin is the AI software engineer, built to help ambitious engineering teams crush their backlogs.",,,,,Devin Docs,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0107,Official Runtime Guides,official-runtime-guides,Blog,πŸ“,"Amp: Agents, Anywhere",https://ampcode.com/news/agents-anywhere,external,ampcode.com,Amp launches remote agent creation on any machine with shell access plus a headless runner mode that lets multiple agents run concurrently without a terminal UI.,Amp launches remote agent creation on any machine with shell access plus a headless runner mode that lets multiple agents run concurrently without a terminal UI.,Amp launches remote agent creation on any machine with shell access plus a headless runner mode that lets multiple agents run concurrently without a terminal UI.,"Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Amp launches remote agent creation on any machine with shell access plus a headless runner mode that lets multiple agents run concurrently without a terminal UI.","Use Amp: Agents, Anywhere to choose an implementation surface for repeatable agent work.","Contextual source from ampcode.com; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,656,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L656,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;context;delegation;state,builder,practitioner-analysis,ok,https://ampcode.com/news/agents-anywhere,"Agents, Anywhere - Amp",Remotely start agents anywhere you can run 'amp',,,,,ampcode.com,,,,domain-fallback,,,,,,,,2026-07-17T17:58:18+00:00 -ale-0108,Research Foundations,research-foundations,Paper,πŸ“„,ReAct: Synergizing Reasoning and Acting in Language Models,https://arxiv.org/abs/2210.03629,external,arxiv.org,Foundational reason-act-observe loop for tool-using language agents.,Foundational reason-act-observe loop for tool-using language agents.,Foundational reason-act-observe loop for tool-using language agents.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Foundational reason-act-observe loop for tool-using language agents.,"Use ReAct: Synergizing Reasoning and Acting in Language Models to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2210.03629; inspect its method and evaluation before treating results as production evidence.,medium,README.md,664,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L664,,Learn,learn,Understand the field and its boundaries.,workspace,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2210.03629,[2210.03629] ReAct: Synergizing Reasoning and Acting in Language Models,"While large language models (LLMs) have demonstrated impressive capabilities across tasks in language understanding and interactive decision making, their abilities for reasoning (e.g. chain-of-thought prompting) and acting (e.g. action plan generation) have primarily been studied as separate topics. In this paper, we explore the use of LLMs to generate both reasoning traces and task-specific actions in an interleaved manner, allowing for greater synergy between the two: reasoning traces help the model induce, track, and update action plans as well as handle exceptions, while actions allow it to interface with external sources, such as knowledge bases or environments, to gather additional information. We apply our approach, named ReAct, to a diverse set of language and decision making tasks and demonstrate its effectiveness over state-of-the-art baselines, as well as improved human interpretability and trustworthiness over methods without reasoning or acting components. Concretely, on question answering (HotpotQA) and fact verification (Fever), ReAct overcomes issues of hallucination and error propagation prevalent in chain-of-thought reasoning by interacting with a simple Wikipedia API, and generates human-like task-solving trajectories that are more interpretable than baselines without reasoning traces. On two interactive decision making benchmarks (ALFWorld and WebShop), ReAct outperforms imitation and reinforcement learning methods by an absolute success rate of 34% and 10% respectively, while being prompted with only one or two in-context examples. Project site with code: https://react-lm.github.io",Shunyu Yao; Jeffrey Zhao; Dian Yu; Nan Du; Izhak Shafran; Karthik Narasimhan; Yuan Cao,2022-10-06,2022,arXiv,arXiv,,v3 is the ICLR camera ready version with some typos fixed. Project site with code: https://react-lm.github.io,cs.CL,arxiv-api,,,,,,,2210.03629,2026-07-17T17:58:18+00:00 -ale-0109,Research Foundations,research-foundations,Paper,πŸ“„,Reflexion: Language Agents with Verbal Reinforcement Learning,https://arxiv.org/abs/2303.11366,external,arxiv.org,Converts environment feedback into written reflections stored in memory for future attempts.,Converts environment feedback into written reflections stored in memory for future attempts.,Converts environment feedback into written reflections stored in memory for future attempts.,Persistent memory is treated as an external runtime artifact. Converts environment feedback into written reflections stored in memory for future attempts.,"Use Reflexion: Language Agents with Verbal Reinforcement Learning to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2303.11366; inspect its method and evaluation before treating results as production evidence.,medium,README.md,665,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L665,,Learn,learn,Understand the field and its boundaries.,context,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2303.11366,[2303.11366] Reflexion: Language Agents with Verbal Reinforcement Learning,"Large language models (LLMs) have been increasingly used to interact with external environments (e.g., games, compilers, APIs) as goal-driven agents. However, it remains challenging for these language agents to quickly and efficiently learn from trial-and-error as traditional reinforcement learning methods require extensive training samples and expensive model fine-tuning. We propose Reflexion, a novel framework to reinforce language agents not by updating weights, but instead through linguistic feedback. Concretely, Reflexion agents verbally reflect on task feedback signals, then maintain their own reflective text in an episodic memory buffer to induce better decision-making in subsequent trials. Reflexion is flexible enough to incorporate various types (scalar values or free-form language) and sources (external or internally simulated) of feedback signals, and obtains significant improvements over a baseline agent across diverse tasks (sequential decision-making, coding, language reasoning). For example, Reflexion achieves a 91% pass@1 accuracy on the HumanEval coding benchmark, surpassing the previous state-of-the-art GPT-4 that achieves 80%. We also conduct ablation and analysis studies using different feedback signals, feedback incorporation methods, and agent types, and provide insights into how they affect performance.",Noah Shinn; Federico Cassano; Edward Berman; Ashwin Gopinath; Karthik Narasimhan; Shunyu Yao,2023-03-20,2023,arXiv,arXiv,,v4 contains a few additional experiments,cs.AI,arxiv-api,,,,,,,2303.11366,2026-07-17T17:58:18+00:00 -ale-0110,Research Foundations,research-foundations,Paper,πŸ“„,Self-Refine: Iterative Refinement with Self-Feedback,https://arxiv.org/abs/2303.17651,external,arxiv.org,Generate-feedback-refine loop where a model improves outputs over repeated passes.,Generate-feedback-refine loop where a model improves outputs over repeated passes.,Generate-feedback-refine loop where a model improves outputs over repeated passes.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Generate-feedback-refine loop where a model improves outputs over repeated passes.,"Use Self-Refine: Iterative Refinement with Self-Feedback to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2303.17651; inspect its method and evaluation before treating results as production evidence.,medium,README.md,666,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L666,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2303.17651,[2303.17651] Self-Refine: Iterative Refinement with Self-Feedback,"Like humans, large language models (LLMs) do not always generate the best output on their first try. Motivated by how humans refine their written text, we introduce Self-Refine, an approach for improving initial outputs from LLMs through iterative feedback and refinement. The main idea is to generate an initial output using an LLMs; then, the same LLMs provides feedback for its output and uses it to refine itself, iteratively. Self-Refine does not require any supervised training data, additional training, or reinforcement learning, and instead uses a single LLM as the generator, refiner, and feedback provider. We evaluate Self-Refine across 7 diverse tasks, ranging from dialog response generation to mathematical reasoning, using state-of-the-art (GPT-3.5, ChatGPT, and GPT-4) LLMs. Across all evaluated tasks, outputs generated with Self-Refine are preferred by humans and automatic metrics over those generated with the same LLM using conventional one-step generation, improving by ~20% absolute on average in task performance. Our work demonstrates that even state-of-the-art LLMs like GPT-4 can be further improved at test time using our simple, standalone approach.",Aman Madaan; Niket Tandon; Prakhar Gupta; Skyler Hallinan; Luyu Gao; Sarah Wiegreffe; Uri Alon; Nouha Dziri; Shrimai Prabhumoye; Yiming Yang; Shashank Gupta; Bodhisattwa Prasad Majumder; Katherine Hermann; Sean Welleck; Amir Yazdanbakhsh; Peter Clark,2023-03-30,2023,arXiv,arXiv,,"Code, data, and demo at https://selfrefine.info/",cs.CL,arxiv-api,,,,,,,2303.17651,2026-07-17T17:58:18+00:00 -ale-0111,Research Foundations,research-foundations,Paper,πŸ“„,CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing,https://arxiv.org/abs/2305.11738,external,arxiv.org,Uses tools to ground critique and correction rather than relying only on introspection.,Uses tools to ground critique and correction rather than relying only on introspection.,Uses tools to ground critique and correction rather than relying only on introspection.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Uses tools to ground critique and correction rather than relying only on introspection.,"Use CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2305.11738; inspect its method and evaluation before treating results as production evidence.,medium,README.md,667,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L667,,Learn,learn,Understand the field and its boundaries.,workspace;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2305.11738,[2305.11738] CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing,"Recent developments in large language models (LLMs) have been impressive. However, these models sometimes show inconsistencies and problematic behavior, such as hallucinating facts, generating flawed code, or creating offensive and toxic content. Unlike these models, humans typically utilize external tools to cross-check and refine their initial content, like using a search engine for fact-checking, or a code interpreter for debugging. Inspired by this observation, we introduce a framework called CRITIC that allows LLMs, which are essentially ""black boxes"" to validate and progressively amend their own outputs in a manner similar to human interaction with tools. More specifically, starting with an initial output, CRITIC interacts with appropriate tools to evaluate certain aspects of the text, and then revises the output based on the feedback obtained during this validation process. Comprehensive evaluations involving free-form question answering, mathematical program synthesis, and toxicity reduction demonstrate that CRITIC consistently enhances the performance of LLMs. Meanwhile, our research highlights the crucial importance of external feedback in promoting the ongoing self-improvement of LLMs.",Zhibin Gou; Zhihong Shao; Yeyun Gong; Yelong Shen; Yujiu Yang; Nan Duan; Weizhu Chen,2023-05-19,2023,arXiv,arXiv,,ICLR 2024,cs.CL,arxiv-api,,,,,,,2305.11738,2026-07-17T17:58:18+00:00 -ale-0112,Research Foundations,research-foundations,Paper,πŸ“„,Tree of Thoughts,https://arxiv.org/abs/2305.10601,external,arxiv.org,Search over multiple reasoning branches; relevant when loop design needs exploration before committing.,Search over multiple reasoning branches; relevant when loop design needs exploration before committing.,Search over multiple reasoning branches; relevant when loop design needs exploration before committing.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Search over multiple reasoning branches; relevant when loop design needs exploration before committing.,"Use Tree of Thoughts to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2305.10601; inspect its method and evaluation before treating results as production evidence.,medium,README.md,668,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L668,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2305.10601,[2305.10601] Tree of Thoughts: Deliberate Problem Solving with Large Language Models,"Language models are increasingly being deployed for general problem solving across a wide range of tasks, but are still confined to token-level, left-to-right decision-making processes during inference. This means they can fall short in tasks that require exploration, strategic lookahead, or where initial decisions play a pivotal role. To surmount these challenges, we introduce a new framework for language model inference, Tree of Thoughts (ToT), which generalizes over the popular Chain of Thought approach to prompting language models, and enables exploration over coherent units of text (thoughts) that serve as intermediate steps toward problem solving. ToT allows LMs to perform deliberate decision making by considering multiple different reasoning paths and self-evaluating choices to decide the next course of action, as well as looking ahead or backtracking when necessary to make global choices. Our experiments show that ToT significantly enhances language models' problem-solving abilities on three novel tasks requiring non-trivial planning or search: Game of 24, Creative Writing, and Mini Crosswords. For instance, in Game of 24, while GPT-4 with chain-of-thought prompting only solved 4% of tasks, our method achieved a success rate of 74%. Code repo with all prompts: https://github.com/princeton-nlp/tree-of-thought-llm.",Shunyu Yao; Dian Yu; Jeffrey Zhao; Izhak Shafran; Thomas L. Griffiths; Yuan Cao; Karthik Narasimhan,2023-05-17,2023,arXiv,arXiv,,NeurIPS 2023 camera ready version. Code repo with all prompts: https://github.com/princeton-nlp/tree-of-thought-llm,cs.CL,arxiv-api,,,,,,,2305.10601,2026-07-17T17:58:18+00:00 -ale-0113,Research Foundations,research-foundations,Paper,πŸ“„,Graph of Thoughts,https://arxiv.org/abs/2308.09687,external,arxiv.org,"Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.","Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.","Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.","Control flow is represented as an inspectable graph rather than an opaque prompt loop. Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.","Use Graph of Thoughts to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2308.09687; inspect its method and evaluation before treating results as production evidence.,medium,README.md,669,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L669,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2308.09687,[2308.09687] Graph of Thoughts: Solving Elaborate Problems with Large Language Models,"We introduce Graph of Thoughts (GoT): a framework that advances prompting capabilities in large language models (LLMs) beyond those offered by paradigms such as Chain-of-Thought or Tree of Thoughts (ToT). The key idea and primary advantage of GoT is the ability to model the information generated by an LLM as an arbitrary graph, where units of information (""LLM thoughts"") are vertices, and edges correspond to dependencies between these vertices. This approach enables combining arbitrary LLM thoughts into synergistic outcomes, distilling the essence of whole networks of thoughts, or enhancing thoughts using feedback loops. We illustrate that GoT offers advantages over state of the art on different tasks, for example increasing the quality of sorting by 62% over ToT, while simultaneously reducing costs by >31%. We ensure that GoT is extensible with new thought transformations and thus can be used to spearhead new prompting schemes. This work brings the LLM reasoning closer to human thinking or brain mechanisms such as recurrence, both of which form complex networks.",Maciej Besta; Nils Blach; Ales Kubicek; Robert Gerstenberger; Michal Podstawski; Lukas Gianinazzi; Joanna Gajda; Tomasz Lehmann; Hubert Niewiadomski; Piotr Nyczyk; Torsten Hoefler,2023-08-18,2023,Proceedings of the AAAI Conference on Artificial Intelligence 2024 (AAAI'24),arXiv,10.1609/aaai.v38i16.29720,,cs.CL,arxiv-api,,,,,,,2308.09687,2026-07-17T17:58:18+00:00 -ale-0114,Research Foundations,research-foundations,Paper,πŸ“„,Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models,https://arxiv.org/abs/2310.04406,external,arxiv.org,"Combines search, action, and environment feedback for language agents.","Combines search, action, and environment feedback for language agents.","Combines search, action, and environment feedback for language agents.","Connects Loop Engineering to prior agent-loop and feedback-loop research. Combines search, action, and environment feedback for language agents.","Use Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2310.04406; inspect its method and evaluation before treating results as production evidence.,medium,README.md,670,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L670,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2310.04406,[2310.04406] Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models,"While language models (LMs) have shown potential across a range of decision-making tasks, their reliance on simple acting processes limits their broad deployment as autonomous agents. In this paper, we introduce Language Agent Tree Search (LATS) -- the first general framework that synergizes the capabilities of LMs in reasoning, acting, and planning. By leveraging the in-context learning ability of LMs, we integrate Monte Carlo Tree Search into LATS to enable LMs as agents, along with LM-powered value functions and self-reflections for proficient exploration and enhanced decision-making. A key feature of our approach is the incorporation of an environment for external feedback, which offers a more deliberate and adaptive problem-solving mechanism that surpasses the constraints of existing techniques. Our experimental evaluation across diverse domains, including programming, interactive question-answering (QA), web navigation, and math, validates the effectiveness and generality of LATS in decision-making while maintaining competitive or improved reasoning performance. Notably, LATS achieves state-of-the-art pass@1 accuracy (92.7%) for programming on HumanEval with GPT-4 and demonstrates gradient-free performance (average score of 75.9) comparable to gradient-based fine-tuning for web navigation on WebShop with GPT-3.5. Code can be found at https://github.com/lapisrocks/LanguageAgentTreeSearch",Andy Zhou; Kai Yan; Michal Shlapentokh-Rothman; Haohan Wang; Yu-Xiong Wang,2023-10-06,2023,arXiv,arXiv,,Code at https://github.com/lapisrocks/LanguageAgentTreeSearch,cs.AI,arxiv-api,,,,,,,2310.04406,2026-07-17T17:58:18+00:00 -ale-0115,Research Foundations,research-foundations,Paper,πŸ“„,Voyager: An Open-Ended Embodied Agent with Large Language Models,https://arxiv.org/abs/2305.16291,external,arxiv.org,"Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.","Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.","Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.","Connects Loop Engineering to prior agent-loop and feedback-loop research. Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.","Use Voyager: An Open-Ended Embodied Agent with Large Language Models to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2305.16291; inspect its method and evaluation before treating results as production evidence.,medium,README.md,671,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L671,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2305.16291,[2305.16291] Voyager: An Open-Ended Embodied Agent with Large Language Models,"We introduce Voyager, the first LLM-powered embodied lifelong learning agent in Minecraft that continuously explores the world, acquires diverse skills, and makes novel discoveries without human intervention. Voyager consists of three key components: 1) an automatic curriculum that maximizes exploration, 2) an ever-growing skill library of executable code for storing and retrieving complex behaviors, and 3) a new iterative prompting mechanism that incorporates environment feedback, execution errors, and self-verification for program improvement. Voyager interacts with GPT-4 via blackbox queries, which bypasses the need for model parameter fine-tuning. The skills developed by Voyager are temporally extended, interpretable, and compositional, which compounds the agent's abilities rapidly and alleviates catastrophic forgetting. Empirically, Voyager shows strong in-context lifelong learning capability and exhibits exceptional proficiency in playing Minecraft. It obtains 3.3x more unique items, travels 2.3x longer distances, and unlocks key tech tree milestones up to 15.3x faster than prior SOTA. Voyager is able to utilize the learned skill library in a new Minecraft world to solve novel tasks from scratch, while other techniques struggle to generalize. We open-source our full codebase and prompts at https://voyager.minedojo.org/.",Guanzhi Wang; Yuqi Xie; Yunfan Jiang; Ajay Mandlekar; Chaowei Xiao; Yuke Zhu; Linxi Fan; Anima Anandkumar,2023-05-25,2023,arXiv,arXiv,,Project website and open-source codebase: https://voyager.minedojo.org/,cs.AI,arxiv-api,,,,,,,2305.16291,2026-07-17T17:58:18+00:00 -ale-0116,Research Foundations,research-foundations,Paper,πŸ“„,Generative Agents: Interactive Simulacra of Human Behavior,https://arxiv.org/abs/2304.03442,external,arxiv.org,Introduces reflection and memory mechanisms for long-running agent behavior.,Introduces reflection and memory mechanisms for long-running agent behavior.,Introduces reflection and memory mechanisms for long-running agent behavior.,Persistent memory is treated as an external runtime artifact. Introduces reflection and memory mechanisms for long-running agent behavior.,"Use Generative Agents: Interactive Simulacra of Human Behavior to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2304.03442; inspect its method and evaluation before treating results as production evidence.,medium,README.md,672,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L672,,Learn,learn,Understand the field and its boundaries.,context;escalation,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2304.03442,[2304.03442] Generative Agents: Interactive Simulacra of Human Behavior,"Believable proxies of human behavior can empower interactive applications ranging from immersive environments to rehearsal spaces for interpersonal communication to prototyping tools. In this paper, we introduce generative agents--computational software agents that simulate believable human behavior. Generative agents wake up, cook breakfast, and head to work; artists paint, while authors write; they form opinions, notice each other, and initiate conversations; they remember and reflect on days past as they plan the next day. To enable generative agents, we describe an architecture that extends a large language model to store a complete record of the agent's experiences using natural language, synthesize those memories over time into higher-level reflections, and retrieve them dynamically to plan behavior. We instantiate generative agents to populate an interactive sandbox environment inspired by The Sims, where end users can interact with a small town of twenty five agents using natural language. In an evaluation, these generative agents produce believable individual and emergent social behaviors: for example, starting with only a single user-specified notion that one agent wants to throw a Valentine's Day party, the agents autonomously spread invitations to the party over the next two days, make new acquaintances, ask each other out on dates to the party, and coordinate to show up for the party together at the right time. We demonstrate through ablation that the components of our agent architecture--observation, planning, and reflection--each contribute critically to the believability of agent behavior. By fusing large language models with computational, interactive agents, this work introduces architectural and interaction patterns for enabling believable simulations of human behavior.",Joon Sung Park; Joseph C. O'Brien; Carrie J. Cai; Meredith Ringel Morris; Percy Liang; Michael S. Bernstein,2023-04-07,2023,arXiv,arXiv,,,cs.HC,arxiv-api,,,,,,,2304.03442,2026-07-17T17:58:18+00:00 -ale-0117,Research Foundations,research-foundations,Paper,πŸ“„,Measuring AI Ability to Complete Long Software Tasks,https://arxiv.org/abs/2503.14499,external,arxiv.org,"METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.","METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.","METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.","Checkpointed state makes long-running agent work recoverable across failures. METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.","Use Measuring AI Ability to Complete Long Software Tasks to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2503.14499; inspect its method and evaluation before treating results as production evidence.,medium,README.md,673,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L673,,Learn,learn,Understand the field and its boundaries.,state;budget;escalation,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2503.14499,[2503.14499] Measuring AI Ability to Complete Long Software Tasks,"Despite rapid progress on AI benchmarks, the real-world meaning of benchmark performance remains unclear. To quantify the capabilities of AI systems in terms of human capabilities, we propose a new metric: 50%-task-completion time horizon. This is the time humans typically take to complete tasks that AI models can complete with 50% success rate. We first timed humans with relevant domain expertise on a combination of RE-Bench, HCAST, and 66 novel shorter tasks. On these tasks, current frontier AI models such as Claude 3.7 Sonnet have a 50% time horizon of around 50 minutes. Furthermore, frontier AI time horizon has been doubling approximately every seven months since 2019, though the trend may have accelerated in 2024. The increase in AI models' time horizons seems to be primarily driven by greater reliability and ability to adapt to mistakes, combined with better logical reasoning and tool use capabilities. We discuss the limitations of our results -- including their degree of external validity -- and the implications of increased autonomy for dangerous capabilities. If these results generalize to real-world software tasks, extrapolation of this trend predicts that within 5 years, AI systems will be capable of automating many software tasks that currently take humans a month.",Thomas Kwa; Ben West; Joel Becker; Amy Deng; Katharyn Garcia; Max Hasin; Sami Jawhar; Megan Kinniment; Nate Rush; Sydney Von Arx; Ryan Bloom; Thomas Broadley; Haoxing Du; Brian Goodrich; Nikola Jurkovic; Luke Harold Miles; Seraphina Nix; Tao Lin; Chris Painter; Neev Parikh; David Rein; Lucas Jun Koba Sato; Hjalmar Wijk; Daniel M. Ziegler; Elizabeth Barnes; Lawrence Chan,2025-03-18,2025,NeurIPS 2025,arXiv,,"v4: added Chris Painter as listed author, consistent with listing in the pdf",cs.AI,arxiv-api,,,,,,,2503.14499,2026-07-17T17:58:18+00:00 +ale-0108,Research Foundations,research-foundations,Paper,πŸ“„,ReAct: Synergizing Reasoning and Acting in Language Models,https://arxiv.org/abs/2210.03629,external,arxiv.org,Foundational reason-act-observe loop for tool-using language agents.,Foundational reason-act-observe loop for tool-using language agents.,Foundational reason-act-observe loop for tool-using language agents.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Foundational reason-act-observe loop for tool-using language agents.,"Use ReAct: Synergizing Reasoning and Acting in Language Models to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2210.03629; inspect its method and evaluation before treating results as production evidence.,medium,README.md,664,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L664,,Learn,learn,Understand the field and its boundaries.,workspace,researcher;evaluator,research-paper,ok,https://openreview.net/forum?id=WE_vluYUL-X,[2210.03629] ReAct: Synergizing Reasoning and Acting in Language Models,"While large language models (LLMs) have demonstrated impressive capabilities across tasks in language understanding and interactive decision making, their abilities for reasoning (e.g. chain-of-thought prompting) and acting (e.g. action plan generation) have primarily been studied as separate topics. In this paper, we explore the use of LLMs to generate both reasoning traces and task-specific actions in an interleaved manner, allowing for greater synergy between the two: reasoning traces help the model induce, track, and update action plans as well as handle exceptions, while actions allow it to interface with external sources, such as knowledge bases or environments, to gather additional information. We apply our approach, named ReAct, to a diverse set of language and decision making tasks and demonstrate its effectiveness over state-of-the-art baselines, as well as improved human interpretability and trustworthiness over methods without reasoning or acting components. Concretely, on question answering (HotpotQA) and fact verification (Fever), ReAct overcomes issues of hallucination and error propagation prevalent in chain-of-thought reasoning by interacting with a simple Wikipedia API, and generates human-like task-solving trajectories that are more interpretable than baselines without reasoning traces. On two interactive decision making benchmarks (ALFWorld and WebShop), ReAct outperforms imitation and reinforcement learning methods by an absolute success rate of 34% and 10% respectively, while being prompted with only one or two in-context examples. Project site with code: https://react-lm.github.io",Shunyu Yao; Jeffrey Zhao; Dian Yu; Nan Du; Izhak Shafran; Karthik Narasimhan; Yuan Cao,2023,2023,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published in International Conference on Learning Representations (ICLR); the linked arXiv record remains available for open access.,cs.CL,OpenReview proceedings record,,,,,,,2210.03629,2026-07-17T17:58:18+00:00 +ale-0109,Research Foundations,research-foundations,Paper,πŸ“„,Reflexion: Language Agents with Verbal Reinforcement Learning,https://arxiv.org/abs/2303.11366,external,arxiv.org,Converts environment feedback into written reflections stored in memory for future attempts.,Converts environment feedback into written reflections stored in memory for future attempts.,Converts environment feedback into written reflections stored in memory for future attempts.,Persistent memory is treated as an external runtime artifact. Converts environment feedback into written reflections stored in memory for future attempts.,"Use Reflexion: Language Agents with Verbal Reinforcement Learning to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2303.11366; inspect its method and evaluation before treating results as production evidence.,medium,README.md,665,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L665,,Learn,learn,Understand the field and its boundaries.,context,researcher;evaluator,research-paper,ok,https://proceedings.neurips.cc/paper_files/paper/2023/hash/1b44b878bb782e6954cd888628510e90-Abstract-Conference.html,[2303.11366] Reflexion: Language Agents with Verbal Reinforcement Learning,"Large language models (LLMs) have been increasingly used to interact with external environments (e.g., games, compilers, APIs) as goal-driven agents. However, it remains challenging for these language agents to quickly and efficiently learn from trial-and-error as traditional reinforcement learning methods require extensive training samples and expensive model fine-tuning. We propose Reflexion, a novel framework to reinforce language agents not by updating weights, but instead through linguistic feedback. Concretely, Reflexion agents verbally reflect on task feedback signals, then maintain their own reflective text in an episodic memory buffer to induce better decision-making in subsequent trials. Reflexion is flexible enough to incorporate various types (scalar values or free-form language) and sources (external or internally simulated) of feedback signals, and obtains significant improvements over a baseline agent across diverse tasks (sequential decision-making, coding, language reasoning). For example, Reflexion achieves a 91% pass@1 accuracy on the HumanEval coding benchmark, surpassing the previous state-of-the-art GPT-4 that achieves 80%. We also conduct ablation and analysis studies using different feedback signals, feedback incorporation methods, and agent types, and provide insights into how they affect performance.",Noah Shinn; Federico Cassano; Edward Berman; Ashwin Gopinath; Karthik Narasimhan; Shunyu Yao,2023,2023,Advances in Neural Information Processing Systems 36 (NeurIPS),Neural Information Processing Systems Foundation,10.52202/075280-0377,Published in Advances in Neural Information Processing Systems 36 (NeurIPS); the linked arXiv record remains available for open access.,cs.AI,NeurIPS proceedings and DOI records,,,,,,,2303.11366,2026-07-17T17:58:18+00:00 +ale-0110,Research Foundations,research-foundations,Paper,πŸ“„,Self-Refine: Iterative Refinement with Self-Feedback,https://arxiv.org/abs/2303.17651,external,arxiv.org,Generate-feedback-refine loop where a model improves outputs over repeated passes.,Generate-feedback-refine loop where a model improves outputs over repeated passes.,Generate-feedback-refine loop where a model improves outputs over repeated passes.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Generate-feedback-refine loop where a model improves outputs over repeated passes.,"Use Self-Refine: Iterative Refinement with Self-Feedback to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2303.17651; inspect its method and evaluation before treating results as production evidence.,medium,README.md,666,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L666,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-paper,ok,https://proceedings.neurips.cc/paper_files/paper/2023/hash/91edff07232fb1b55a505a9e9f6c0ff3-Abstract-Conference.html,[2303.17651] Self-Refine: Iterative Refinement with Self-Feedback,"Like humans, large language models (LLMs) do not always generate the best output on their first try. Motivated by how humans refine their written text, we introduce Self-Refine, an approach for improving initial outputs from LLMs through iterative feedback and refinement. The main idea is to generate an initial output using an LLMs; then, the same LLMs provides feedback for its output and uses it to refine itself, iteratively. Self-Refine does not require any supervised training data, additional training, or reinforcement learning, and instead uses a single LLM as the generator, refiner, and feedback provider. We evaluate Self-Refine across 7 diverse tasks, ranging from dialog response generation to mathematical reasoning, using state-of-the-art (GPT-3.5, ChatGPT, and GPT-4) LLMs. Across all evaluated tasks, outputs generated with Self-Refine are preferred by humans and automatic metrics over those generated with the same LLM using conventional one-step generation, improving by ~20% absolute on average in task performance. Our work demonstrates that even state-of-the-art LLMs like GPT-4 can be further improved at test time using our simple, standalone approach.",Aman Madaan; Niket Tandon; Prakhar Gupta; Skyler Hallinan; Luyu Gao; Sarah Wiegreffe; Uri Alon; Nouha Dziri; Shrimai Prabhumoye; Yiming Yang; Shashank Gupta; Bodhisattwa Prasad Majumder; Katherine Hermann; Sean Welleck; Amir Yazdanbakhsh; Peter Clark,2023,2023,Advances in Neural Information Processing Systems 36 (NeurIPS),Neural Information Processing Systems Foundation,,Published in Advances in Neural Information Processing Systems 36 (NeurIPS); the linked arXiv record remains available for open access.,cs.CL,NeurIPS proceedings record,,,,,,,2303.17651,2026-07-17T17:58:18+00:00 +ale-0111,Research Foundations,research-foundations,Paper,πŸ“„,CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing,https://arxiv.org/abs/2305.11738,external,arxiv.org,Uses tools to ground critique and correction rather than relying only on introspection.,Uses tools to ground critique and correction rather than relying only on introspection.,Uses tools to ground critique and correction rather than relying only on introspection.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Uses tools to ground critique and correction rather than relying only on introspection.,"Use CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2305.11738; inspect its method and evaluation before treating results as production evidence.,medium,README.md,667,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L667,,Learn,learn,Understand the field and its boundaries.,workspace;verification,researcher;evaluator,research-paper,ok,https://proceedings.iclr.cc/paper_files/paper/2024/hash/fef126561bbf9d4467dbb8d27334b8fe-Abstract-Conference.html,[2305.11738] CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing,"Recent developments in large language models (LLMs) have been impressive. However, these models sometimes show inconsistencies and problematic behavior, such as hallucinating facts, generating flawed code, or creating offensive and toxic content. Unlike these models, humans typically utilize external tools to cross-check and refine their initial content, like using a search engine for fact-checking, or a code interpreter for debugging. Inspired by this observation, we introduce a framework called CRITIC that allows LLMs, which are essentially ""black boxes"" to validate and progressively amend their own outputs in a manner similar to human interaction with tools. More specifically, starting with an initial output, CRITIC interacts with appropriate tools to evaluate certain aspects of the text, and then revises the output based on the feedback obtained during this validation process. Comprehensive evaluations involving free-form question answering, mathematical program synthesis, and toxicity reduction demonstrate that CRITIC consistently enhances the performance of LLMs. Meanwhile, our research highlights the crucial importance of external feedback in promoting the ongoing self-improvement of LLMs.",Zhibin Gou; Zhihong Shao; Yeyun Gong; Yelong Shen; Yujiu Yang; Nan Duan; Weizhu Chen,2024,2024,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published in International Conference on Learning Representations (ICLR); the linked arXiv record remains available for open access.,cs.CL,ICLR proceedings record,,,,,,,2305.11738,2026-07-17T17:58:18+00:00 +ale-0112,Research Foundations,research-foundations,Paper,πŸ“„,Tree of Thoughts,https://arxiv.org/abs/2305.10601,external,arxiv.org,Search over multiple reasoning branches; relevant when loop design needs exploration before committing.,Search over multiple reasoning branches; relevant when loop design needs exploration before committing.,Search over multiple reasoning branches; relevant when loop design needs exploration before committing.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Search over multiple reasoning branches; relevant when loop design needs exploration before committing.,"Use Tree of Thoughts to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2305.10601; inspect its method and evaluation before treating results as production evidence.,medium,README.md,668,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L668,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-paper,ok,https://proceedings.neurips.cc/paper_files/paper/2023/hash/271db9922b8d1f4dd7aaef84ed5ac703-Abstract.html,[2305.10601] Tree of Thoughts: Deliberate Problem Solving with Large Language Models,"Language models are increasingly being deployed for general problem solving across a wide range of tasks, but are still confined to token-level, left-to-right decision-making processes during inference. This means they can fall short in tasks that require exploration, strategic lookahead, or where initial decisions play a pivotal role. To surmount these challenges, we introduce a new framework for language model inference, Tree of Thoughts (ToT), which generalizes over the popular Chain of Thought approach to prompting language models, and enables exploration over coherent units of text (thoughts) that serve as intermediate steps toward problem solving. ToT allows LMs to perform deliberate decision making by considering multiple different reasoning paths and self-evaluating choices to decide the next course of action, as well as looking ahead or backtracking when necessary to make global choices. Our experiments show that ToT significantly enhances language models' problem-solving abilities on three novel tasks requiring non-trivial planning or search: Game of 24, Creative Writing, and Mini Crosswords. For instance, in Game of 24, while GPT-4 with chain-of-thought prompting only solved 4% of tasks, our method achieved a success rate of 74%. Code repo with all prompts: https://github.com/princeton-nlp/tree-of-thought-llm.",Shunyu Yao; Dian Yu; Jeffrey Zhao; Izhak Shafran; Thomas L. Griffiths; Yuan Cao; Karthik Narasimhan,2023,2023,Advances in Neural Information Processing Systems 36 (NeurIPS),Neural Information Processing Systems Foundation,,Published in Advances in Neural Information Processing Systems 36 (NeurIPS); the linked arXiv record remains available for open access.,cs.CL,NeurIPS proceedings record,,,,,,,2305.10601,2026-07-17T17:58:18+00:00 +ale-0113,Research Foundations,research-foundations,Paper,πŸ“„,Graph of Thoughts,https://arxiv.org/abs/2308.09687,external,arxiv.org,"Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.","Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.","Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.","Control flow is represented as an inspectable graph rather than an opaque prompt loop. Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.","Use Graph of Thoughts to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2308.09687; inspect its method and evaluation before treating results as production evidence.,medium,README.md,669,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L669,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-paper,ok,https://ojs.aaai.org/index.php/AAAI/article/view/29720,[2308.09687] Graph of Thoughts: Solving Elaborate Problems with Large Language Models,"We introduce Graph of Thoughts (GoT): a framework that advances prompting capabilities in large language models (LLMs) beyond those offered by paradigms such as Chain-of-Thought or Tree of Thoughts (ToT). The key idea and primary advantage of GoT is the ability to model the information generated by an LLM as an arbitrary graph, where units of information (""LLM thoughts"") are vertices, and edges correspond to dependencies between these vertices. This approach enables combining arbitrary LLM thoughts into synergistic outcomes, distilling the essence of whole networks of thoughts, or enhancing thoughts using feedback loops. We illustrate that GoT offers advantages over state of the art on different tasks, for example increasing the quality of sorting by 62% over ToT, while simultaneously reducing costs by >31%. We ensure that GoT is extensible with new thought transformations and thus can be used to spearhead new prompting schemes. This work brings the LLM reasoning closer to human thinking or brain mechanisms such as recurrence, both of which form complex networks.",Maciej Besta; Nils Blach; Ales Kubicek; Robert Gerstenberger; Michal Podstawski; Lukas Gianinazzi; Joanna Gajda; Tomasz Lehmann; Hubert Niewiadomski; Piotr Nyczyk; Torsten Hoefler,2024-03-24,2024,Proceedings of the AAAI Conference on Artificial Intelligence 38 (AAAI),Association for the Advancement of Artificial Intelligence (AAAI),10.1609/aaai.v38i16.29720,Published in Proceedings of the AAAI Conference on Artificial Intelligence 38 (AAAI); the linked arXiv record remains available for open access.,cs.CL,AAAI proceedings and DOI records,,,,,,,2308.09687,2026-07-17T17:58:18+00:00 +ale-0114,Research Foundations,research-foundations,Paper,πŸ“„,Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models,https://arxiv.org/abs/2310.04406,external,arxiv.org,"Combines search, action, and environment feedback for language agents.","Combines search, action, and environment feedback for language agents.","Combines search, action, and environment feedback for language agents.","Connects Loop Engineering to prior agent-loop and feedback-loop research. Combines search, action, and environment feedback for language agents.","Use Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2310.04406; inspect its method and evaluation before treating results as production evidence.,medium,README.md,670,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L670,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-paper,ok,https://proceedings.mlr.press/v235/zhou24r.html,[2310.04406] Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models,"While language models (LMs) have shown potential across a range of decision-making tasks, their reliance on simple acting processes limits their broad deployment as autonomous agents. In this paper, we introduce Language Agent Tree Search (LATS) -- the first general framework that synergizes the capabilities of LMs in reasoning, acting, and planning. By leveraging the in-context learning ability of LMs, we integrate Monte Carlo Tree Search into LATS to enable LMs as agents, along with LM-powered value functions and self-reflections for proficient exploration and enhanced decision-making. A key feature of our approach is the incorporation of an environment for external feedback, which offers a more deliberate and adaptive problem-solving mechanism that surpasses the constraints of existing techniques. Our experimental evaluation across diverse domains, including programming, interactive question-answering (QA), web navigation, and math, validates the effectiveness and generality of LATS in decision-making while maintaining competitive or improved reasoning performance. Notably, LATS achieves state-of-the-art pass@1 accuracy (92.7%) for programming on HumanEval with GPT-4 and demonstrates gradient-free performance (average score of 75.9) comparable to gradient-based fine-tuning for web navigation on WebShop with GPT-3.5. Code can be found at https://github.com/lapisrocks/LanguageAgentTreeSearch",Andy Zhou; Kai Yan; Michal Shlapentokh-Rothman; Haohan Wang; Yu-Xiong Wang,2024,2024,Proceedings of the 41st International Conference on Machine Learning (ICML),PMLR,,Published in Proceedings of the 41st International Conference on Machine Learning (ICML); the linked arXiv record remains available for open access.,cs.AI,PMLR proceedings record,,,,,,,2310.04406,2026-07-17T17:58:18+00:00 +ale-0115,Research Foundations,research-foundations,Paper,πŸ“„,Voyager: An Open-Ended Embodied Agent with Large Language Models,https://arxiv.org/abs/2305.16291,external,arxiv.org,"Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.","Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.","Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.","Connects Loop Engineering to prior agent-loop and feedback-loop research. Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.","Use Voyager: An Open-Ended Embodied Agent with Large Language Models to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2305.16291; inspect its method and evaluation before treating results as production evidence.,medium,README.md,671,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L671,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-paper,ok,https://openreview.net/forum?id=ehfRiF0R3a,[2305.16291] Voyager: An Open-Ended Embodied Agent with Large Language Models,"We introduce Voyager, the first LLM-powered embodied lifelong learning agent in Minecraft that continuously explores the world, acquires diverse skills, and makes novel discoveries without human intervention. Voyager consists of three key components: 1) an automatic curriculum that maximizes exploration, 2) an ever-growing skill library of executable code for storing and retrieving complex behaviors, and 3) a new iterative prompting mechanism that incorporates environment feedback, execution errors, and self-verification for program improvement. Voyager interacts with GPT-4 via blackbox queries, which bypasses the need for model parameter fine-tuning. The skills developed by Voyager are temporally extended, interpretable, and compositional, which compounds the agent's abilities rapidly and alleviates catastrophic forgetting. Empirically, Voyager shows strong in-context lifelong learning capability and exhibits exceptional proficiency in playing Minecraft. It obtains 3.3x more unique items, travels 2.3x longer distances, and unlocks key tech tree milestones up to 15.3x faster than prior SOTA. Voyager is able to utilize the learned skill library in a new Minecraft world to solve novel tasks from scratch, while other techniques struggle to generalize. We open-source our full codebase and prompts at https://voyager.minedojo.org/.",Guanzhi Wang; Yuqi Xie; Yunfan Jiang; Ajay Mandlekar; Chaowei Xiao; Yuke Zhu; Linxi Fan; Anima Anandkumar,2024,2024,Transactions on Machine Learning Research (TMLR),OpenReview,,Published in Transactions on Machine Learning Research (TMLR); the linked arXiv record remains available for open access.,cs.AI,TMLR OpenReview record,,,,,,,2305.16291,2026-07-17T17:58:18+00:00 +ale-0116,Research Foundations,research-foundations,Paper,πŸ“„,Generative Agents: Interactive Simulacra of Human Behavior,https://arxiv.org/abs/2304.03442,external,arxiv.org,Introduces reflection and memory mechanisms for long-running agent behavior.,Introduces reflection and memory mechanisms for long-running agent behavior.,Introduces reflection and memory mechanisms for long-running agent behavior.,Persistent memory is treated as an external runtime artifact. Introduces reflection and memory mechanisms for long-running agent behavior.,"Use Generative Agents: Interactive Simulacra of Human Behavior to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2304.03442; inspect its method and evaluation before treating results as production evidence.,medium,README.md,672,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L672,,Learn,learn,Understand the field and its boundaries.,context;escalation,researcher;evaluator,research-paper,ok,https://doi.org/10.1145/3586183.3606763,[2304.03442] Generative Agents: Interactive Simulacra of Human Behavior,"Believable proxies of human behavior can empower interactive applications ranging from immersive environments to rehearsal spaces for interpersonal communication to prototyping tools. In this paper, we introduce generative agents--computational software agents that simulate believable human behavior. Generative agents wake up, cook breakfast, and head to work; artists paint, while authors write; they form opinions, notice each other, and initiate conversations; they remember and reflect on days past as they plan the next day. To enable generative agents, we describe an architecture that extends a large language model to store a complete record of the agent's experiences using natural language, synthesize those memories over time into higher-level reflections, and retrieve them dynamically to plan behavior. We instantiate generative agents to populate an interactive sandbox environment inspired by The Sims, where end users can interact with a small town of twenty five agents using natural language. In an evaluation, these generative agents produce believable individual and emergent social behaviors: for example, starting with only a single user-specified notion that one agent wants to throw a Valentine's Day party, the agents autonomously spread invitations to the party over the next two days, make new acquaintances, ask each other out on dates to the party, and coordinate to show up for the party together at the right time. We demonstrate through ablation that the components of our agent architecture--observation, planning, and reflection--each contribute critically to the believability of agent behavior. By fusing large language models with computational, interactive agents, this work introduces architectural and interaction patterns for enabling believable simulations of human behavior.",Joon Sung Park; Joseph C. O'Brien; Carrie J. Cai; Meredith Ringel Morris; Percy Liang; Michael S. Bernstein,2023-10-29,2023,Proceedings of the 36th ACM Symposium on User Interface Software and Technology (UIST),Association for Computing Machinery,10.1145/3586183.3606763,Published in Proceedings of the 36th ACM Symposium on User Interface Software and Technology (UIST); the linked arXiv record remains available for open access.,cs.HC,ACM DOI record,,,,,,,2304.03442,2026-07-17T17:58:18+00:00 +ale-0117,Research Foundations,research-foundations,Paper,πŸ“„,Measuring AI Ability to Complete Long Software Tasks,https://arxiv.org/abs/2503.14499,external,arxiv.org,"METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.","METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.","METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.","Checkpointed state makes long-running agent work recoverable across failures. METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.","Use Measuring AI Ability to Complete Long Software Tasks to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2503.14499; inspect its method and evaluation before treating results as production evidence.,medium,README.md,673,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L673,,Learn,learn,Understand the field and its boundaries.,state;budget;escalation,researcher;evaluator,research-paper,ok,https://proceedings.neurips.cc/paper_files/paper/2025/hash/85069585133c4c168c865e65d72e9775-Abstract-Conference.html,[2503.14499] Measuring AI Ability to Complete Long Software Tasks,"Despite rapid progress on AI benchmarks, the real-world meaning of benchmark performance remains unclear. To quantify the capabilities of AI systems in terms of human capabilities, we propose a new metric: 50%-task-completion time horizon. This is the time humans typically take to complete tasks that AI models can complete with 50% success rate. We first timed humans with relevant domain expertise on a combination of RE-Bench, HCAST, and 66 novel shorter tasks. On these tasks, current frontier AI models such as Claude 3.7 Sonnet have a 50% time horizon of around 50 minutes. Furthermore, frontier AI time horizon has been doubling approximately every seven months since 2019, though the trend may have accelerated in 2024. The increase in AI models' time horizons seems to be primarily driven by greater reliability and ability to adapt to mistakes, combined with better logical reasoning and tool use capabilities. We discuss the limitations of our results -- including their degree of external validity -- and the implications of increased autonomy for dangerous capabilities. If these results generalize to real-world software tasks, extrapolation of this trend predicts that within 5 years, AI systems will be capable of automating many software tasks that currently take humans a month.",Thomas Kwa; Ben West; Joel Becker; Amy Deng; Katharyn Garcia; Max Hasin; Sami Jawhar; Megan Kinniment; Nate Rush; Sydney Von Arx; Ryan Bloom; Thomas Broadley; Haoxing Du; Brian Goodrich; Nikola Jurkovic; Luke Harold Miles; Seraphina Nix; Tao Lin; Chris Painter; Neev Parikh; David Rein; Lucas Jun Koba Sato; Hjalmar Wijk; Daniel M. Ziegler; Elizabeth Barnes; Lawrence Chan,2025,2025,Advances in Neural Information Processing Systems 38 (NeurIPS),Neural Information Processing Systems Foundation,,Published in Advances in Neural Information Processing Systems 38 (NeurIPS); the linked arXiv record remains available for open access.,cs.AI,NeurIPS proceedings record,,,,,,,2503.14499,2026-07-17T17:58:18+00:00 ale-0118,Research Foundations,research-foundations,Blog,πŸ“,Measuring AI Ability to Complete Long Tasks,https://metr.org/blog/2025-03-19-measuring-ai-ability-to-complete-long-tasks/,external,metr.org,Accessible summary of the 50% task-completion time horizon and its doubling trend.,Accessible summary of the 50% task-completion time horizon and its doubling trend.,Accessible summary of the 50% task-completion time horizon and its doubling trend.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Accessible summary of the 50% task-completion time horizon and its doubling trend.,"Use Measuring AI Ability to Complete Long Tasks to understand the evidence, vocabulary, and lineage behind recurring agent systems.","Contextual source from metr.org; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,674,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L674,,Learn,learn,Understand the field and its boundaries.,exit,builder,practitioner-analysis,ok,https://metr.org/blog/2025-03-19-measuring-ai-ability-to-complete-long-tasks/,Measuring AI Ability to Complete Long Tasks - METR Substack twitter Bluesky,"We propose measuring AI performance in terms of the *length* of tasks AI agents can complete. We show that this metric has been consistently exponentially increasing over the past 6 years, with a doubling time of around 7 months. Extrapolating this trend predicts that, in under a decade, we will see AI agents that can independently complete a large fraction of software tasks that currently take humans days or weeks.",,2025-03-19,2025,METR Blog,metr.org,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 -ale-0119,Research Foundations,research-foundations,Paper,πŸ“„,Reflection-Driven Control for Trustworthy Code Agents,https://arxiv.org/abs/2512.21354,external,arxiv.org,Elevates reflection from an external pass to an internal control loop that monitors the agent's decision path during generation and constrains risky steps with low overhead.,Elevates reflection from an external pass to an internal control loop that monitors the agent's decision path during generation and constrains risky steps with low overhead.,Elevates reflection from an external pass to an internal control loop that monitors the agent's decision path during generation and constrains risky steps with low overhead.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Elevates reflection from an external pass to an internal control loop that monitors the agent's decision path during generation and constrains risky steps with low overhead.,"Use Reflection-Driven Control for Trustworthy Code Agents to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2512.21354; inspect its method and evaluation before treating results as production evidence.,medium,README.md,675,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L675,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2512.21354,[2512.21354] Reflection-Driven Control for Trustworthy Code Agents,"Contemporary large language model (LLM) agents are remarkably capable, but they still lack reliable safety controls and can produce unconstrained, unpredictable, and even actively harmful outputs. To address this, we introduce Reflection-Driven Control, a standardized and pluggable control module that can be seamlessly integrated into general agent architectures. Reflection-Driven Control elevates ""self-reflection"" from a post hoc patch into an explicit step in the agent's own reasoning process: during generation, the agent continuously runs an internal reflection loop that monitors and evaluates its own decision path. When potential risks are detected, the system retrieves relevant repair examples and secure coding guidelines from an evolving reflective memory, injecting these evidence-based constraints directly into subsequent reasoning steps. We instantiate Reflection-Driven Control in the setting of secure code generation and systematically evaluate it across eight classes of security-critical programming tasks. Empirical results show that Reflection-Driven Control substantially improves the security and policy compliance of generated code while largely preserving functional correctness, with minimal runtime and token overhead. Taken together, these findings indicate that Reflection-Driven Control is a practical path toward trustworthy AI coding agents: it enables designs that are simultaneously autonomous, safer by construction, and auditable.",Bin Wang; Jiazheng Quan; Xingrui Yu; Hansen Hu; Yuhao; Ivor Tsang,2025-12-22,2025,arXiv,arXiv,,Accepted to AAAI 2026 Workshop on Trust and Control in Agentic AI (TrustAgent),cs.CR,arxiv-api,,,,,,,2512.21354,2026-07-17T17:58:18+00:00 +ale-0119,Research Foundations,research-foundations,Paper,πŸ“„,Reflection-Driven Control for Trustworthy Code Agents,https://arxiv.org/abs/2512.21354,external,arxiv.org,Elevates reflection from an external pass to an internal control loop that monitors the agent's decision path during generation and constrains risky steps with low overhead.,Elevates reflection from an external pass to an internal control loop that monitors the agent's decision path during generation and constrains risky steps with low overhead.,Elevates reflection from an external pass to an internal control loop that monitors the agent's decision path during generation and constrains risky steps with low overhead.,Connects Loop Engineering to prior agent-loop and feedback-loop research. Elevates reflection from an external pass to an internal control loop that monitors the agent's decision path during generation and constrains risky steps with low overhead.,"Use Reflection-Driven Control for Trustworthy Code Agents to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2512.21354; inspect its method and evaluation before treating results as production evidence.,medium,README.md,675,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L675,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-paper,ok,https://openreview.net/forum?id=vUtz66IHD1,[2512.21354] Reflection-Driven Control for Trustworthy Code Agents,"Contemporary large language model (LLM) agents are remarkably capable, but they still lack reliable safety controls and can produce unconstrained, unpredictable, and even actively harmful outputs. To address this, we introduce Reflection-Driven Control, a standardized and pluggable control module that can be seamlessly integrated into general agent architectures. Reflection-Driven Control elevates ""self-reflection"" from a post hoc patch into an explicit step in the agent's own reasoning process: during generation, the agent continuously runs an internal reflection loop that monitors and evaluates its own decision path. When potential risks are detected, the system retrieves relevant repair examples and secure coding guidelines from an evolving reflective memory, injecting these evidence-based constraints directly into subsequent reasoning steps. We instantiate Reflection-Driven Control in the setting of secure code generation and systematically evaluate it across eight classes of security-critical programming tasks. Empirical results show that Reflection-Driven Control substantially improves the security and policy compliance of generated code while largely preserving functional correctness, with minimal runtime and token overhead. Taken together, these findings indicate that Reflection-Driven Control is a practical path toward trustworthy AI coding agents: it enables designs that are simultaneously autonomous, safer by construction, and auditable.",Bin Wang; Jiazheng Quan; Xingrui Yu; Hansen Hu; Yuhao; Ivor Tsang,2026,2026,AAAI Workshop on Trust and Control in Agentic AI (TrustAgent),Association for the Advancement of Artificial Intelligence (AAAI),,Published in AAAI Workshop on Trust and Control in Agentic AI (TrustAgent); the linked arXiv record remains available for open access.,cs.CR,AAAI workshop OpenReview record,,,,,,,2512.21354,2026-07-17T17:58:18+00:00 ale-0120,Research Foundations,research-foundations,Paper,πŸ“„,Hyperagents,https://arxiv.org/abs/2603.19461,external,arxiv.org,"Self-referential agents that fold task-solving and self-modification into editable programs, extending the Darwin Godel Machine toward open-ended self-improvement, the loop where an agent rewrites its own improvement mechanism across runs.","Self-referential agents that fold task-solving and self-modification into editable programs, extending the Darwin Godel Machine toward open-ended self-improvement, the loop where an agent rewrites its own improvement mechanism across runs.","Self-referential agents that fold task-solving and self-modification into editable programs, extending the Darwin Godel Machine toward open-ended self-improvement, the loop where an agent rewrites its own improvement mechanism across runs.","Connects Loop Engineering to prior agent-loop and feedback-loop research. Self-referential agents that fold task-solving and self-modification into editable programs, extending the Darwin Godel Machine toward open-ended self-improvement, the loop where an agent rewrites its own improvement mechanism across runs.","Use Hyperagents to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2603.19461; inspect its method and evaluation before treating results as production evidence.,medium,README.md,676,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L676,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2603.19461,[2603.19461] Hyperagents,"Self-improving AI systems aim to reduce reliance on human engineering by learning to improve their own learning and problem-solving processes. Existing approaches to self-improvement rely on fixed, handcrafted meta-level mechanisms, fundamentally limiting how fast such systems can improve. The Darwin G\""odel Machine (DGM) demonstrates open-ended self-improvement in coding by repeatedly generating and evaluating self-modified variants. Because both evaluation and self-modification are coding tasks, gains in coding ability can translate into gains in self-improvement ability. However, this alignment does not generally hold beyond coding domains. We introduce \textbf{hyperagents}, self-referential agents that integrate a task agent (which solves the target task) and a meta agent (which modifies itself and the task agent) into a single editable program. Crucially, the meta-level modification procedure is itself editable, enabling metacognitive self-modification, improving not only the task-solving behavior, but also the mechanism that generates future improvements. We instantiate this framework by extending DGM to create DGM-Hyperagents (DGM-H), eliminating the assumption of domain-specific alignment between task performance and self-modification skill to potentially support self-accelerating progress on any computable task. Across diverse domains, the DGM-H improves performance over time and outperforms baselines without self-improvement or open-ended exploration, as well as prior self-improving systems. Furthermore, the DGM-H improves the process by which it generates new agents (e.g., persistent memory, performance tracking), and these meta-level improvements transfer across domains and accumulate across runs. DGM-Hyperagents offer a glimpse of open-ended AI systems that do not merely search for better solutions, but continually improve their search for how to improve.",Jenny Zhang; Bingchen Zhao; Wannan Yang; Jakob Foerster; Jeff Clune; Minqi Jiang; Sam Devlin; Tatiana Shavrina,2026-03-19,2026,arXiv,arXiv,,Code at https://github.com/facebookresearch/Hyperagents,cs.AI,arxiv-api,,,,,,,2603.19461,2026-07-17T17:58:18+00:00 ale-0121,Research Foundations,research-foundations,Paper,πŸ“„,PARC: An Autonomous Self-Reflective Coding Agent for Robust Execution of Long-Horizon Tasks,https://arxiv.org/abs/2512.03549,external,arxiv.org,Hierarchical plan-execute-assess loops that detect and correct strategic errors during multi-hour autonomous runs.,Hierarchical plan-execute-assess loops that detect and correct strategic errors during multi-hour autonomous runs.,Hierarchical plan-execute-assess loops that detect and correct strategic errors during multi-hour autonomous runs.,The work targets tasks that exceed a single context window or prompt session. Hierarchical plan-execute-assess loops that detect and correct strategic errors during multi-hour autonomous runs.,"Use PARC: An Autonomous Self-Reflective Coding Agent for Robust Execution of Long-Horizon Tasks to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2512.03549; inspect its method and evaluation before treating results as production evidence.,medium,README.md,677,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L677,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2512.03549,[2512.03549] PARC: An Autonomous Self-Reflective Coding Agent for Robust Execution of Long-Horizon Tasks,"We introduce PARC, a coding agent for the autonomous and robust execution of long-horizon computational tasks. PARC is built on a hierarchical multi-agent architecture incorporating task planning, execution, and a mechanism that evaluates its own actions and their outcomes from an independent context and provides feedback, namely self-assessment and self-feedback. This design enables PARC to detect and correct high-level strategic errors and sustain progress without human intervention. We evaluate PARC across computational science and data science tasks. In materials science, it autonomously reproduces key results from studies on lithium-ion conduction and alloy segregation. In particular, it coordinates dozens of parallel simulation tasks, each requiring roughly 43 hours of computation, managing orchestration, monitoring, and error correction end-to-end. In Kaggle-based experiments, starting from minimal natural-language instructions, PARC conducts data analysis and implements search strategies, producing solutions competitive with human-engineered baselines. These results highlight the potential of integrating a hierarchical multi-agent system with self-assessment and self-feedback to enable AI systems capable of independent, large-scale scientific and analytical work.",Yuki Orimo; Iori Kurata; Hodaka Mori; Ryuhei Okuno; Ryohto Sawada; Daisuke Okanohara,2025-12-03,2025,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2512.03549,2026-07-17T17:58:18+00:00 ale-0122,Research Foundations,research-foundations,Paper,πŸ“„,When the Specification Emerges: Benchmarking Faithfulness Loss in Long-Horizon Coding Agents,https://arxiv.org/abs/2603.17104,external,arxiv.org,"Measures how agents drift from intent when specifications arrive incrementally across a long loop, and proposes a mitigation that recovers most of the loss.","Measures how agents drift from intent when specifications arrive incrementally across a long loop, and proposes a mitigation that recovers most of the loss.","Measures how agents drift from intent when specifications arrive incrementally across a long loop, and proposes a mitigation that recovers most of the loss.","The work targets tasks that exceed a single context window or prompt session. Measures how agents drift from intent when specifications arrive incrementally across a long loop, and proposes a mitigation that recovers most of the loss.","Use When the Specification Emerges: Benchmarking Faithfulness Loss in Long-Horizon Coding Agents to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2603.17104; inspect its method and evaluation before treating results as production evidence.,medium,README.md,678,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L678,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2603.17104,[2603.17104] When the Specification Emerges: Benchmarking Faithfulness Loss in Long-Horizon Coding Agents,"Current coding-agent benchmarks usually pro- vide the full task specification upfront. Real research coding often does not: the intended system is progressively disclosed through in- teraction, requiring the agent to track durable design commitments across a long session. We introduce a benchmark for this setting and study faithfulne Ss Loss U nder eM ergent s Pecification (SLUMP), defined as the reduc- tion in final implementation faithfulness un- der emergent specification relative to a single- shot specification control. The benchmark con- tains 20 recent ML papers (10 ICML 2025, 10 NeurIPS 2025), 371 atomic verifiable compo- nents, and interaction scripts of approximately 60 coding requests that progressively disclose the target design without revealing the paper itself. Final repositories are scored with a five-level component-faithfulness rubric and accompanied by an exposure audit to verify that scored components are recoverable from the visible interaction. Evaluated on Claude Code and Codex, the single-shot specification control achieves higher overall implementation fidelity on 16/20 and 14/20 papers, respectively. Structural integration degrades under emergent specification on both platforms, while seman- tic faithfulness loss is substantial on Claude Code and small on Codex. As a mitigation case study, we introduce ProjectGuard, an exter- nal project-state layer for specification tracking. On Claude Code, ProjectGuard recovers 90% of the faithfulness gap, increases fully faith- ful components from 118 to 181, and reduces severe failures from 72 to 49. These results identify specification tracking as a distinct eval- uation target for long-horizon coding agents.",Lu Yan; Xuan Chen; Xiangyu Zhang,2026-03-17,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2603.17104,2026-07-17T17:58:18+00:00 @@ -134,14 +134,14 @@ ale-0132,Research Foundations,research-foundations,Paper,πŸ“„,TTHE: Test-Time Ha ale-0133,Research Foundations,research-foundations,Paper,πŸ“„,DeepSearch-World: Self-Distillation for Deep Search Agents in a Verifiable Environment,https://arxiv.org/abs/2607.07820,external,arxiv.org,"Introduces DeepSearch-Evolve, where a deep search agent improves by self-distilling its own trajectories inside a deterministic 420K-task verifiable environment, progress verification, grounded reflection, and failure recovery replace teacher trajectories and sparse RL reward, lifting a 9B model to 31.2% BrowseComp and 61.5% GAIA.","Introduces DeepSearch-Evolve, where a deep search agent improves by self-distilling its own trajectories inside a deterministic 420K-task verifiable environment, progress verification, grounded reflection, and failure recovery replace teacher trajectories and sparse RL reward, lifting a 9B model to 31.2% BrowseComp and 61.5% GAIA.","Introduces DeepSearch-Evolve, where a deep search agent improves by self-distilling its own trajectories inside a deterministic 420K-task verifiable environment, progress verification, grounded reflection, and failure recovery replace teacher trajectories and sparse RL reward, lifting a 9B model to 31.2% BrowseComp and 61.5% GAIA.","Verification is promoted from a final check to a loop-control signal. Introduces DeepSearch-Evolve, where a deep search agent improves by self-distilling its own trajectories inside a deterministic 420K-task verifiable environment, progress verification, grounded reflection, and failure recovery replace teacher trajectories and sparse RL reward, lifting a 9B model to 31.2% BrowseComp and 61.5% GAIA.","Use DeepSearch-World: Self-Distillation for Deep Search Agents in a Verifiable Environment to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.07820; inspect its method and evaluation before treating results as production evidence.,medium,README.md,689,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L689,,Learn,learn,Understand the field and its boundaries.,verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.07820,[2607.07820] DeepSearch-World: Self-Distillation for Deep Search Agents in a Verifiable Environment,"Training tool-use agents to improve from their own experience remains challenging, as supervised fine-tuning relies on fixed teacher-distilled trajectories, while sparse-reward reinforcement learning provides weak supervision for long-horizon interactions. We present DeepSearch-Evolve, a self-distillation framework for web agents built on DeepSearch-World, a deterministic and verifiable environment with reproducible search and page-reading tools. DeepSearch-World contains 420K multi-hop QA tasks constructed from entity-level random walks and supports key agentic cognitive behaviors useful for self-evolving, including progress verification, grounded reflection, and failure recovery. DeepSearch-Evolve iteratively performs trajectory generation, filtering, data mixing, and fine-tuning to train stronger agents. Without distillation from more capable models, DeepSearch-World-9B achieves competitive performance compared with open-source agents, reaching 31.2% on BrowseComp, 61.5% on GAIA, and 93.4% on HotpotQA, showing that verifiable environments enable scalable self-evolution for long-horizon web agents. We will release the environment, 420K training pool, validation set, model, and code to facilitate future research on self-improving deep search agents.",Xinyu Geng; Xuanhua He; Sixiang Chen; Yanjing Xiao; Fan Zhang; Shijue Huang; Haitao Mi; Zhenwen Liang; Tianqing Fang; Yi R. Fung,2026-07-08,2026,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,2607.07820,2026-07-17T17:58:18+00:00 ale-0134,Research Foundations,research-foundations,Paper,πŸ“„,What Makes a Good Bug Report for an AI Agent?,https://arxiv.org/abs/2607.07593,external,arxiv.org,"Statistical analysis of 433 issues plus controlled multi-model experiments showing LLM repair agents succeed more when bug reports carry reproduction scripts, fix suggestions, and fault-localization cues, while longer natural-language reports correlate with lower success, directly informing how a loop's work-discovery step should specify tasks before dispatching agents.","Statistical analysis of 433 issues plus controlled multi-model experiments showing LLM repair agents succeed more when bug reports carry reproduction scripts, fix suggestions, and fault-localization cues, while longer natural-language reports correlate with lower success, directly informing how a loop's work-discovery step should specify tasks before dispatching agents.","Statistical analysis of 433 issues plus controlled multi-model experiments showing LLM repair agents succeed more when bug reports carry reproduction scripts, fix suggestions, and fault-localization cues, while longer natural-language reports correlate with lower success, directly informing how a loop's work-discovery step should specify tasks before dispatching agents.","Connects Loop Engineering to prior agent-loop and feedback-loop research. Statistical analysis of 433 issues plus controlled multi-model experiments showing LLM repair agents succeed more when bug reports carry reproduction scripts, fix suggestions, and fault-localization cues, while longer natural-language reports correlate with lower success, directly informing how a loop's work-discovery step should specify tasks before dispatching agents.","Use What Makes a Good Bug Report for an AI Agent? to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.07593; inspect its method and evaluation before treating results as production evidence.,medium,README.md,690,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L690,,Learn,learn,Understand the field and its boundaries.,intake,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.07593,[2607.07593] What Makes a Good Bug Report for an AI Agent?,"Automated program repair (APR) agents are transitioning from research benchmarks to developer workflows, yet they still begin with bug reports written for human developers. While decades of research have established what makes a good bug report for humans (e.g., steps to reproduce, stack traces), it remains unclear whether these features transfer to LLM-based agents. We study this question in two analyses. First, we use statistical modeling to examine associations between 27 bug-report features and repair success across 433 SWE-bench Verified issues attempted by 87 repair agents. We find that fix suggestions, reproduction scripts, repository source code, and localization info are associated with higher resolution likelihood, while longer reports are associated with lower odds. Second, we conduct controlled ablations across 2 models and 17 problem-statement mutations on SWE-bench Pro, varying the information available to an agent while holding the underlying task fixed. We remove or isolate selected bug-report content, delete fault-localization cues, and test structural changes that flatten lists or remove section headers. We find that both models depend on localization cues and expected behavior, and that structural changes alone can reduce solve rates, even without removing any content. The two models diverge in how they handle missing information: Qwen searches more widely and can exhaust its turn budget, while Gemma commits to a plausible interpretation early and patches on it. Our findings indicate that a good bug report for an agent overlaps with, but is not identical to, a good report for a human: agents benefit most from concrete, executable, and well-localized information, whereas some qualities long emphasized for human readers, such as natural language steps to reproduce and readable descriptions, contribute little or even correlate with lower success.",Lara Khatib; Noble Saji Mathews; Meiyappan Nagappan; Pengyu Nie; Thomas Zimmermann,2026-07-08,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.07593,2026-07-17T17:58:18+00:00 ale-0135,Research Foundations,research-foundations,Paper,πŸ“„,AutoPersonas: A Multi-Timescale Loop Engine for Open-Ended Persona Evolution,https://arxiv.org/abs/2607.08252,external,arxiv.org,"Names self-locking as a runtime failure mode of continuing agent loops, where accumulated state and history pull generation toward stale repetition (over 95% rolling action-repetition across an eight-model 40-day stress test), and proposes a multi-timescale loop that admits divergent material only through evidence-governed absorption, cutting macro-theme repetition from 61.8% to 36.3%.","Names self-locking as a runtime failure mode of continuing agent loops, where accumulated state and history pull generation toward stale repetition (over 95% rolling action-repetition across an eight-model 40-day stress test), and proposes a multi-timescale loop that admits divergent material only through evidence-governed absorption, cutting macro-theme repetition from 61.8% to 36.3%.","Names self-locking as a runtime failure mode of continuing agent loops, where accumulated state and history pull generation toward stale repetition (over 95% rolling action-repetition across an eight-model 40-day stress test), and proposes a multi-timescale loop that admits divergent material only through evidence-governed absorption, cutting macro-theme repetition from 61.8% to 36.3%.","State persistence is explicit enough for repeated runs and handoff. Names self-locking as a runtime failure mode of continuing agent loops, where accumulated state and history pull generation toward stale repetition (over 95% rolling action-repetition across an eight-model 40-day stress test), and proposes a multi-timescale loop that admits divergent material only through evidence-governed absorption, cutting macro-theme repetition from 61.8% to 36.3%.","Use AutoPersonas: A Multi-Timescale Loop Engine for Open-Ended Persona Evolution to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.08252; inspect its method and evaluation before treating results as production evidence.,medium,README.md,691,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L691,,Learn,learn,Understand the field and its boundaries.,verification;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.08252,[2607.08252] AutoPersonas: A Multi-Timescale Loop Engine for Open-Ended Persona Evolution,"Long-term persona agents must remain identifiable while adapting to new events, relationships, evidence, and social conditions. We identify self-locking as a runtime failure mode in continuing persona-life loops: locally plausible events keep appearing while the generated life collapses toward familiar environments, weak relationships, suspended decisions, and stale life stages. We trace this failure to model-level convergence toward high-probability behavioral channels and system-level context gravity from State, memory, history, and environment summaries. We introduce AutoPersonas, a multi-timescale life-environment engine for bounded persona-level recursive self-evolution. It separates environment-side Occurrences, accumulated Observations, and persona State. Its OSO loop admits divergent future-facing material while requiring evidence-governed absorption before State or reachability changes. A three-year compressed simulation exposed environment watermark shells, occurrence-hardening gaps, slow-change accumulation failures, recursive indecision, and weak relationship persistence. An eight-model 40-day stress test generated 1,600 events and found mean rolling 5-day action-category repetition of 95.2%-97.6%, with all models crossing 90% by day 11. Semantic re-keeping found 79.0%-88.0% macro-theme repetition across all direct-loop runs. In a same-runtime 40-day A/B, context-slice masking plus per-sample divergence targeting reduced macro-theme repetition from 61.8% to 36.3% and roughly doubled cumulative theme count. A juvenile-goblin fictional-world run reproduced the anti-fixation regime without hard real-world intrusions. These results support a bounded claim: separating controlled divergence from evidence-governed absorption can reduce persona-environment self-locking while preserving identity continuity.",Mengchen Li,2026-07-09,2026,arXiv,arXiv,,"52 pages, 13 figures/tables, ancillary public-safe evaluation artifacts included",cs.AI,arxiv-api,,,,,,,2607.08252,2026-07-17T17:58:18+00:00 -ale-0136,Research Foundations,research-foundations,Paper,πŸ“„,Agentic Data Environments,https://arxiv.org/abs/2607.07397,external,arxiv.org,"Vision paper from the IEEE Data Engineering Bulletin reframing data systems as the active execution environment agents operate in, spanning files, APIs, applications, and system state, arguing the substrate under recurring agent loops should both amplify agent capability and enforce safety guarantees that bound the cost of failure.","Vision paper from the IEEE Data Engineering Bulletin reframing data systems as the active execution environment agents operate in, spanning files, APIs, applications, and system state, arguing the substrate under recurring agent loops should both amplify agent capability and enforce safety guarantees that bound the cost of failure.","Vision paper from the IEEE Data Engineering Bulletin reframing data systems as the active execution environment agents operate in, spanning files, APIs, applications, and system state, arguing the substrate under recurring agent loops should both amplify agent capability and enforce safety guarantees that bound the cost of failure.","State persistence is explicit enough for repeated runs and handoff. Vision paper from the IEEE Data Engineering Bulletin reframing data systems as the active execution environment agents operate in, spanning files, APIs, applications, and system state, arguing the substrate under recurring agent loops should both amplify agent capability and enforce safety guarantees that bound the cost of failure.","Use Agentic Data Environments to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.07397; inspect its method and evaluation before treating results as production evidence.,medium,README.md,692,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L692,,Learn,learn,Understand the field and its boundaries.,state;budget,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.07397,[2607.07397] Agentic Data Environments,"Autonomous agents promise substantial gains in speed, scale, and labor efficiency, but their failures can impose abrupt and often irreversible costs. The central challenge for agentic automation is therefore to increase the benefits of automation while bounding the consequences of failure. While databases remain central to modern computing, agents operate over a broader data environment spanning files, APIs, applications, and system state. In this talk, I will outline early work on Agentic Data Environments -- the execution substrate in which agents operate -- that both amplify agent capabilities and enforce safety guarantees. This perspective reframes data systems from passive stores of state into active substrates for safe, reliable execution.",Elaine Ang; Chenxi Huang; Georgios Liargkovas; Jerry Liu; Jinhui Liu; Nikos Pagonas; Charlie Summers; Haonan Wang; Jiakai Xu; Tianle Zhou; Yusen Zhang; Zhou Yu; Zhuo Zhang; Tianyi Peng; Kostis Kaffes; Eugene Wu,2026-07-08,2026,IEEE Data Bulletin Vol. 50 No. 1 2026,arXiv,,,cs.AI,arxiv-api,,,,,,,2607.07397,2026-07-17T17:58:18+00:00 +ale-0136,Research Foundations,research-foundations,Paper,πŸ“„,Agentic Data Environments,https://arxiv.org/abs/2607.07397,external,arxiv.org,"Vision paper from the IEEE Data Engineering Bulletin reframing data systems as the active execution environment agents operate in, spanning files, APIs, applications, and system state, arguing the substrate under recurring agent loops should both amplify agent capability and enforce safety guarantees that bound the cost of failure.","Vision paper from the IEEE Data Engineering Bulletin reframing data systems as the active execution environment agents operate in, spanning files, APIs, applications, and system state, arguing the substrate under recurring agent loops should both amplify agent capability and enforce safety guarantees that bound the cost of failure.","Vision paper from the IEEE Data Engineering Bulletin reframing data systems as the active execution environment agents operate in, spanning files, APIs, applications, and system state, arguing the substrate under recurring agent loops should both amplify agent capability and enforce safety guarantees that bound the cost of failure.","State persistence is explicit enough for repeated runs and handoff. Vision paper from the IEEE Data Engineering Bulletin reframing data systems as the active execution environment agents operate in, spanning files, APIs, applications, and system state, arguing the substrate under recurring agent loops should both amplify agent capability and enforce safety guarantees that bound the cost of failure.","Use Agentic Data Environments to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.07397; inspect its method and evaluation before treating results as production evidence.,medium,README.md,692,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L692,,Learn,learn,Understand the field and its boundaries.,state;budget,researcher;evaluator,research-paper,ok,http://sites.computer.org/debull/A26mar/A26MAR-CD.pdf#page=7,[2607.07397] Agentic Data Environments,"Autonomous agents promise substantial gains in speed, scale, and labor efficiency, but their failures can impose abrupt and often irreversible costs. The central challenge for agentic automation is therefore to increase the benefits of automation while bounding the consequences of failure. While databases remain central to modern computing, agents operate over a broader data environment spanning files, APIs, applications, and system state. In this talk, I will outline early work on Agentic Data Environments -- the execution substrate in which agents operate -- that both amplify agent capabilities and enforce safety guarantees. This perspective reframes data systems from passive stores of state into active substrates for safe, reliable execution.",Elaine Ang; Chenxi Huang; Georgios Liargkovas; Jerry Liu; Jinhui Liu; Nikos Pagonas; Charlie Summers; Haonan Wang; Jiakai Xu; Tianle Zhou; Yusen Zhang; Zhou Yu; Zhuo Zhang; Tianyi Peng; Kostis Kaffes; Eugene Wu,2026-03,2026,IEEE Data Engineering Bulletin 50(1),IEEE,,Published in IEEE Data Engineering Bulletin 50(1); the linked arXiv record remains available for open access.,cs.AI,IEEE Data Engineering Bulletin record,,,,,,,2607.07397,2026-07-17T17:58:18+00:00 ale-0137,Research Foundations,research-foundations,Paper,πŸ“„,"Better Harnesses, Smaller Models: Building 90% Cheaper Agents via Automated Harness Adaptation",https://arxiv.org/abs/2607.08938,external,arxiv.org,"Meta agent maps observed failure modes to harness adaptation strategies, letting small-model agents recover ~90% of frontier-LLM performance at ~4% of the cost, the harness itself becomes the optimization target.","Meta agent maps observed failure modes to harness adaptation strategies, letting small-model agents recover ~90% of frontier-LLM performance at ~4% of the cost, the harness itself becomes the optimization target.","Meta agent maps observed failure modes to harness adaptation strategies, letting small-model agents recover ~90% of frontier-LLM performance at ~4% of the cost, the harness itself becomes the optimization target.","Connects Loop Engineering to prior agent-loop and feedback-loop research. Meta agent maps observed failure modes to harness adaptation strategies, letting small-model agents recover ~90% of frontier-LLM performance at ~4% of the cost, the harness itself becomes the optimization target.","Use Better Harnesses, Smaller Models: Building 90% Cheaper Agents via Automated Harness Adaptation to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.08938; inspect its method and evaluation before treating results as production evidence.,medium,README.md,693,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L693,,Learn,learn,Understand the field and its boundaries.,budget,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.08938,"[2607.08938] Better Harnesses, Smaller Models: Building 90% Cheaper Agents via Automated Harness Adaptation","Frontier LLM agents are automating many business tasks, but their high inference cost makes large-scale deployment unsustainable. Small language models (SLMs) offer a cheaper alternative, yet they typically fall short when swapped into a harness designed for a frontier LLM. We show that for many routine business tasks, SLM agents can match LLM performance at 90% lower cost, when paired with an adapted harness that can be automatically discovered by a meta agent. The key insight is that much of the task difficulty is shared across instances and can be lifted from the model into the harness via tailored instructions, tools, and orchestration loops. To study this systematically, we create a framework that maps agent failure modes to harness adaptation strategies, and build a harness optimizer that automatically discovers effective adaptations from failure trajectories. Across seven business-oriented agentic tasks and three SLM families, we found optimized harnesses significantly improve performance on 16 of 21 task-SLM pairs, with seven pairs closing the SLM-LLM performance gap and the best SLM agent recovering 89.7% of LLM performance at 4% of the cost. Our analysis further shows that adaptation works best for tasks with more repetitive workflows and for SLMs with sufficient base capabilities. Together, these results suggest that harness adaptation can expand the practical deployment range of SLM agents in routine business tasks.",Chenyang Yang; Xinran Zhao; Tongshuang Wu; Christian KΓ€stner,2026-07-09,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.08938,2026-07-17T17:58:18+00:00 ale-0138,Research Foundations,research-foundations,Paper,πŸ“„,Inside the Skill Market: From Software Engineering Activities to Reusable Agent Skills,https://arxiv.org/abs/2607.09065,external,arxiv.org,"First large-scale empirical study of public agent-skill repositories and marketplaces, characterizing which software-engineering activities get packaged as reusable skills, their coverage across the development lifecycle, how they evolve, and how they are evaluated - an activity-centric map of the skills layer that agent loops compose (Cao, Cheung, et al., HKUST).","First large-scale empirical study of public agent-skill repositories and marketplaces, characterizing which software-engineering activities get packaged as reusable skills, their coverage across the development lifecycle, how they evolve, and how they are evaluated - an activity-centric map of the skills layer that agent loops compose (Cao, Cheung, et al., HKUST).","First large-scale empirical study of public agent-skill repositories and marketplaces, characterizing which software-engineering activities get packaged as reusable skills, their coverage across the development lifecycle, how they evolve, and how they are evaluated - an activity-centric map of the skills layer that agent loops compose (Cao, Cheung, et al., HKUST).","Connects Loop Engineering to prior agent-loop and feedback-loop research. First large-scale empirical study of public agent-skill repositories and marketplaces, characterizing which software-engineering activities get packaged as reusable skills, their coverage across the development lifecycle, how they evolve, and how they are evaluated - an activity-centric map of the skills layer that agent loops compose (Cao, Cheung, et al., HKUST).","Use Inside the Skill Market: From Software Engineering Activities to Reusable Agent Skills to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.09065; inspect its method and evaluation before treating results as production evidence.,medium,README.md,694,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L694,,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.09065,[2607.09065] Inside the Skill Market: From Software Engineering Activities to Reusable Agent Skills,"Software engineering (abbrev. SE) has continuously evolved through increasingly powerful forms of reuse, from source code and libraries to components and services. Recent advances in AI agents have introduced a potentially new reusable artifact: skills. Emerging agent skill repositories and marketplaces enable developers to package, share, and reuse SE expertise as reusable skills. This trend raises a fundamental question: what SE activities are being encapsulated into reusable skills? Existing studies primarily focus on a broad range of skills acquisition, safety, or benchmarking, while lacking a systematic understanding of SE-specific skills and their coverage across the software development lifecycle. To address this gap, we conduct the first large-scale empirical study of SE skills in public repositories and marketplaces. We collect and analyze a large corpus of SE skills, examining the activities they encapsulate, lifecycle coverage, evolution characteristics, and evaluation mechanisms. Our findings reveal that SE activities are increasingly becoming reusable artifacts via skills and suggest promising research opportunities for skill recommendation and engineering-oriented structuring, as well as the need for mechanisms to encapsulate high-context SE activities into reusable skills. Overall, our study provides the first activity-centric characterization of SE skills and reveals how SE activities are increasingly being transformed into reusable skills. These findings offer new insights into skill reuse, ecosystem development, and the future of agent-centric SE.",Jialun Cao; Xinru Yan; Songqiang Chen; Yaojie Lu; Zhongxin Liu; Shing-Chi Cheung,2026-07-10,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.09065,2026-07-17T17:58:18+00:00 ale-0139,Research Foundations,research-foundations,Blog,πŸ“,Harness Engineering for Self-Improvement,https://lilianweng.github.io/posts/2026-07-04-harness/,external,lilianweng.github.io,"Lilian Weng's deep-dive arguing the harness, the system surrounding a base model that orchestrates execution, matters as much as raw intelligence for recursive self-improvement, with a taxonomy of harness components and failure modes.","Lilian Weng's deep-dive arguing the harness, the system surrounding a base model that orchestrates execution, matters as much as raw intelligence for recursive self-improvement, with a taxonomy of harness components and failure modes.","Lilian Weng's deep-dive arguing the harness, the system surrounding a base model that orchestrates execution, matters as much as raw intelligence for recursive self-improvement, with a taxonomy of harness components and failure modes.","Orchestration and control flow are made explicit and inspectable. Lilian Weng's deep-dive arguing the harness, the system surrounding a base model that orchestrates execution, matters as much as raw intelligence for recursive self-improvement, with a taxonomy of harness components and failure modes.","Use Harness Engineering for Self-Improvement to understand the evidence, vocabulary, and lineage behind recurring agent systems.","Contextual source from lilianweng.github.io; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,695,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L695,,Learn,learn,Understand the field and its boundaries.,delegation,builder,practitioner-analysis,ok,https://lilianweng.github.io/posts/2026-07-04-harness/,Harness Engineering for Self-Improvement | Lil'Log,"The concept of recursive self-improvement (RSI) dates back to I. J. Good (1965), where he defined an β€œultraintelligent machine” as a system that can surpass humans in all intellectual activities and design better machines to improve itself. Yudkowsky (2008) used the phrase β€œrecursive self-improvement” for a specific feedback loop: an AI uses its current intelligence to improve the cognitive machinery that produces its intelligence. This feedback loop in modern AI may indicate the model rewriting its own weights directly, or more broadly the model improves the training pipeline and the deployment system, which in turn enables a better successor model with improved performance across economically valuable tasks. The speed of research development in AI has been shown to drastically accelerated in frontier labs (Anthropic; OpenAI).",Lilian Weng,2026-07-04,2026,,lilianweng.github.io,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0140,Research Foundations,research-foundations,Paper,πŸ“„,"Compile, Then Page: Executable SOP Programs and a Capability-Gated Runtime",https://arxiv.org/abs/2607.11346,external,arxiv.org,"Compiles safety-critical standard operating procedures into executable pseudo-code run by a program-guided stack machine that pages the active frame while the LLM does semantic execution, finding runtime guidance is capability-gated (it helps strong models and harms weak ones) across a six-model, seven-domain SOPBench study.","Compiles safety-critical standard operating procedures into executable pseudo-code run by a program-guided stack machine that pages the active frame while the LLM does semantic execution, finding runtime guidance is capability-gated (it helps strong models and harms weak ones) across a six-model, seven-domain SOPBench study.","Compiles safety-critical standard operating procedures into executable pseudo-code run by a program-guided stack machine that pages the active frame while the LLM does semantic execution, finding runtime guidance is capability-gated (it helps strong models and harms weak ones) across a six-model, seven-domain SOPBench study.","Connects Loop Engineering to prior agent-loop and feedback-loop research. Compiles safety-critical standard operating procedures into executable pseudo-code run by a program-guided stack machine that pages the active frame while the LLM does semantic execution, finding runtime guidance is capability-gated (it helps strong models and harms weak ones) across a six-model, seven-domain SOPBench study.","Use Compile, Then Page: Executable SOP Programs and a Capability-Gated Runtime to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.11346; inspect its method and evaluation before treating results as production evidence.,medium,README.md,696,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L696,2026-07-15,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.11346,"[2607.11346] Compile, Then Page: Executable SOP Programs and a Capability-Gated Runtime for Procedural LLM Agents","Enterprise agents must follow long-horizon, conditional, safety-critical standard operating procedures (SOPs). We compile machine-readable SOP constraints into executable pseudo-code and run them with a program-guided (PG) stack machine that pages the active frame while an LLM performs semantic execution. A three-arm SOPBench study across six models separates representation from runtime: compiled text never significantly hurts and gains up to 16.0 points where official prose underperforms. Runtime guidance is capability-gated. Two strong models independently show positive seven-domain PG contrasts (58:19 and 75:31 discordant pairs), whereas weak models are harmed. A full-program cursor ablation (active frame first, complete program retained) recovers much of the strong-model refusal gain; selective visibility adds a smaller improvement. Paired probe and audit measurements track this divide to spontaneous state discipline rather than reconstruction ability. On Bank the three primary arms rise from 70.4 to 86.4 to 92.8, with 100% refusal correctness. Practical guidance: compile first; enable active-frame paging only after a model-level discipline check.",Chenglin Yu; Li Yin; Ying Yu; Qingxin Fan; RunyangRay Zhong; Hongxia Yang; Ming Li,2026-07-13,2026,arXiv,arXiv,,"9 pages, 3 figures, 5 tables",cs.AI,arxiv-api,,,,,,,2607.11346,2026-07-17T17:58:18+00:00 ale-0141,Research Foundations,research-foundations,Paper,πŸ“„,Mako: A Self-Evolving Agentic Operating System for Autonomous Web Exploitation,https://arxiv.org/abs/2607.11288,external,arxiv.org,"Industrial self-evolving agentic OS that treats exploit capability as a mutable, versioned kernel: the agent observes its own failures, synthesizes new capabilities, proves them against a live target, and hot-loads them back, a self-improvement loop with in-loop verification.","Industrial self-evolving agentic OS that treats exploit capability as a mutable, versioned kernel: the agent observes its own failures, synthesizes new capabilities, proves them against a live target, and hot-loads them back, a self-improvement loop with in-loop verification.","Industrial self-evolving agentic OS that treats exploit capability as a mutable, versioned kernel: the agent observes its own failures, synthesizes new capabilities, proves them against a live target, and hot-loads them back, a self-improvement loop with in-loop verification.","Verification is promoted from a final check to a loop-control signal. Industrial self-evolving agentic OS that treats exploit capability as a mutable, versioned kernel: the agent observes its own failures, synthesizes new capabilities, proves them against a live target, and hot-loads them back, a self-improvement loop with in-loop verification.","Use Mako: A Self-Evolving Agentic Operating System for Autonomous Web Exploitation to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.11288; inspect its method and evaluation before treating results as production evidence.,medium,README.md,697,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L697,2026-07-15,Learn,learn,Understand the field and its boundaries.,verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.11288,[2607.11288] Mako: A Self-Evolving Agentic Operating System (SE-AOS) for Autonomous Web Exploitation,"We introduce the Self-Evolving Agentic Operating System (SE-AOS): a new class of AI agent that treats exploit capability as a mutable, versioned kernel it extends at runtime, observing its own failures, synthesising new capabilities, proving them against a live target, and hot-loading them back into itself. Mako is the first SE-AOS instance for security research and the autonomous web exploitation engine developed within LaunchSafe. LaunchSafe builds autonomous security agents for continuous offensive testing and agent-driven security research; Mako is the core engine behind that platform. On the public XBOW validation-benchmarks, 104 containerised, CTF-style web applications spanning 26 vulnerability classes across three difficulty tiers, Mako achieves full-suite coverage: it drives every one of the 104 targets to emit a cryptographically fresh, per-build flag, under a verification regime that makes fabricated or memorised results impossible. Our central result is a law of autonomous exploitation: once a capability exists and is discoverable, difficulty collapses; capability, not reasoning, is what is scarce, together with an architecture and formalism that turn that law into a self-improving system. Mako further runs a gated self-evolution loop that proposes, sandboxes, and commits improvements to its own agents and rules when fitness does not regress. We deliberately withhold the operational results, payloads, exploit chains, and tool source, because a system that reduces full-spectrum web exploitation to a repeatable, machine-speed pipeline is dual-use research of concern. We publish the science; we withhold the weapon.",Praneeth Narisetty; Shiva Nagendra Babu Kore,2026-07-13,2026,arXiv,arXiv,,"13 pages, 10 figures, 8 tables",cs.CR,arxiv-api,,,,,,,2607.11288,2026-07-17T17:58:18+00:00 ale-0142,Research Foundations,research-foundations,Paper,πŸ“„,How Do Practitioners Build SE Agents? Insights from a Mixed-Methods Study,https://arxiv.org/abs/2607.10856,external,arxiv.org,"Mixed-methods study of how practitioners actually design software-engineering agents, surfacing the recurring loop, harness, and verification decisions teams make and where their mental models diverge from benchmark assumptions.","Mixed-methods study of how practitioners actually design software-engineering agents, surfacing the recurring loop, harness, and verification decisions teams make and where their mental models diverge from benchmark assumptions.","Mixed-methods study of how practitioners actually design software-engineering agents, surfacing the recurring loop, harness, and verification decisions teams make and where their mental models diverge from benchmark assumptions.","Verification is promoted from a final check to a loop-control signal. Mixed-methods study of how practitioners actually design software-engineering agents, surfacing the recurring loop, harness, and verification decisions teams make and where their mental models diverge from benchmark assumptions.","Use How Do Practitioners Build SE Agents? Insights from a Mixed-Methods Study to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.10856; inspect its method and evaluation before treating results as production evidence.,medium,README.md,698,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L698,2026-07-15,Learn,learn,Understand the field and its boundaries.,verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.10856,[2607.10856] How Do Practitioners Build SE Agents? Insights from a Mixed-Methods Study,"The rise of Software Engineering (SE) agents, i.e., LLM-based agents that can understand large codebases and carry out engineering tasks with limited human intervention, has been marked by rapid advances and adoption, but little is known about how developers build these systems in practice: existing studies mine repositories or examine deployment, but few investigate how SE agents are constructed. Through semi-structured interviews with 20 practitioners from 12 organizations and an online survey of 80 practitioners, this paper is the first to study how SE processes are changing in the development of SE agents and what challenges developers face. We find that as implementation becomes cheaper, bottlenecks shift rather than disappear: long-standing non-coding work such as requirements, coordination, review, and deployment becomes more visible, while reviewing and evaluating agent output becomes new and central. We characterize a seven-stage workflow and a shift toward evaluation-driven development, in which evaluation steers iteration and specifications become versioned artifacts read by both humans and agents. We further identify six challenges that teams face, together with the practices they adopt to address them, including unreliable evaluation signals, comprehension debt as code outpaces understanding, and behavioral changes introduced by provider-side model updates.",Yunbo Lyu; David Williams; Jieke Shi; Zhensu Sun; Chao Peng; Zhou Yang; Federica Sarro; David Lo,2026-07-12,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.10856,2026-07-17T17:58:18+00:00 -ale-0143,Research Foundations,research-foundations,Paper,πŸ“„,Dynamic Agent Skills: A Lifecycle Survey and Taxonomy of Evolving Skill Libraries,https://arxiv.org/abs/2607.10113,external,arxiv.org,"Survey and taxonomy of how agent skill libraries are created, evaluated, retired, and reused over time, organizing the fast-growing self-evolving-skills literature into a lifecycle framework.","Survey and taxonomy of how agent skill libraries are created, evaluated, retired, and reused over time, organizing the fast-growing self-evolving-skills literature into a lifecycle framework.","Survey and taxonomy of how agent skill libraries are created, evaluated, retired, and reused over time, organizing the fast-growing self-evolving-skills literature into a lifecycle framework.","Connects Loop Engineering to prior agent-loop and feedback-loop research. Survey and taxonomy of how agent skill libraries are created, evaluated, retired, and reused over time, organizing the fast-growing self-evolving-skills literature into a lifecycle framework.","Use Dynamic Agent Skills: A Lifecycle Survey and Taxonomy of Evolving Skill Libraries to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.10113; inspect its method and evaluation before treating results as production evidence.,medium,README.md,699,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L699,2026-07-15,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.10113,[2607.10113] Dynamic Agent Skills: A Lifecycle Survey and Taxonomy of Evolving Skill Libraries,"Large language model agents increasingly store reusable procedures outside the model. These reusable procedures are often called \emph{skills}: they may be code functions, natural-language instructions, SKILL.md packages, workflow graphs, or learned adapters that a future agent can retrieve and invoke. This taxonomy-driven survey asks how such skill libraries change over time. Across a $124$-paper $2023$--$2026$ audit set, we synthesize dynamic skill systems as \emph{lifecycle-managed, verified, evolving artifact stores}: agents collect evidence from interaction, propose skill updates, verify and admit candidates, organize them for retrieval and composition, repair or prune stale entries, and govern sharing through provenance and rollback. We organize the literature around three survey tools. First, a $\text{six}$-sense taxonomy distinguishes the structurally different artifacts called ``skills'' in current papers. Second, an $\text{eight}$-stage lifecycle architecture identifies the recurring design decisions behind evidence acquisition, proposal, verification/admission, storage, retrieval/composition, maintenance, distillation/portability, and governance. Third, a lightweight skill-record schema and $\text{ten}$-operator vocabulary provide common terms for comparing library updates without elevating them into a separate method contribution. Using this structure, we synthesize evidence-graded patterns with explicit caveats: admission and repair are repeatedly important, verifier quality materially affects skill-aware RL, flat retrieval can degrade as libraries grow, and current benchmarks still under-report library trajectories, usage--utility gaps, and safety surfaces. We close with concrete reporting standards and open problems for evaluating dynamic skills as changing libraries rather than static prompt or tool collections.",Yubo Li,2026-07-11,2026,"Transactions on Machine Learning Research, 2026",arXiv,,"Accepted by TMLR (2026.07), OpenReview Link: https://openreview.net/forum?id=cjU3YbcRr8",cs.AI,arxiv-api,,,,,,,2607.10113,2026-07-17T17:58:18+00:00 +ale-0143,Research Foundations,research-foundations,Paper,πŸ“„,Dynamic Agent Skills: A Lifecycle Survey and Taxonomy of Evolving Skill Libraries,https://arxiv.org/abs/2607.10113,external,arxiv.org,"Survey and taxonomy of how agent skill libraries are created, evaluated, retired, and reused over time, organizing the fast-growing self-evolving-skills literature into a lifecycle framework.","Survey and taxonomy of how agent skill libraries are created, evaluated, retired, and reused over time, organizing the fast-growing self-evolving-skills literature into a lifecycle framework.","Survey and taxonomy of how agent skill libraries are created, evaluated, retired, and reused over time, organizing the fast-growing self-evolving-skills literature into a lifecycle framework.","Connects Loop Engineering to prior agent-loop and feedback-loop research. Survey and taxonomy of how agent skill libraries are created, evaluated, retired, and reused over time, organizing the fast-growing self-evolving-skills literature into a lifecycle framework.","Use Dynamic Agent Skills: A Lifecycle Survey and Taxonomy of Evolving Skill Libraries to understand the evidence, vocabulary, and lineage behind recurring agent systems.",Research source arXiv:2607.10113; inspect its method and evaluation before treating results as production evidence.,medium,README.md,699,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L699,2026-07-15,Learn,learn,Understand the field and its boundaries.,whole-loop,researcher;evaluator,research-paper,ok,https://openreview.net/forum?id=cjU3YbcRr8,[2607.10113] Dynamic Agent Skills: A Lifecycle Survey and Taxonomy of Evolving Skill Libraries,"Large language model agents increasingly store reusable procedures outside the model. These reusable procedures are often called \emph{skills}: they may be code functions, natural-language instructions, SKILL.md packages, workflow graphs, or learned adapters that a future agent can retrieve and invoke. This taxonomy-driven survey asks how such skill libraries change over time. Across a $124$-paper $2023$--$2026$ audit set, we synthesize dynamic skill systems as \emph{lifecycle-managed, verified, evolving artifact stores}: agents collect evidence from interaction, propose skill updates, verify and admit candidates, organize them for retrieval and composition, repair or prune stale entries, and govern sharing through provenance and rollback. We organize the literature around three survey tools. First, a $\text{six}$-sense taxonomy distinguishes the structurally different artifacts called ``skills'' in current papers. Second, an $\text{eight}$-stage lifecycle architecture identifies the recurring design decisions behind evidence acquisition, proposal, verification/admission, storage, retrieval/composition, maintenance, distillation/portability, and governance. Third, a lightweight skill-record schema and $\text{ten}$-operator vocabulary provide common terms for comparing library updates without elevating them into a separate method contribution. Using this structure, we synthesize evidence-graded patterns with explicit caveats: admission and repair are repeatedly important, verifier quality materially affects skill-aware RL, flat retrieval can degrade as libraries grow, and current benchmarks still under-report library trajectories, usage--utility gaps, and safety surfaces. We close with concrete reporting standards and open problems for evaluating dynamic skills as changing libraries rather than static prompt or tool collections.",Yubo Li,2026,2026,Transactions on Machine Learning Research (TMLR),OpenReview,,Accepted at Transactions on Machine Learning Research (TMLR); the linked arXiv record is the available paper version.,cs.AI,Current arXiv acceptance note and OpenReview record,,,,,,,2607.10113,2026-07-17T17:58:18+00:00 ale-0144,Agent Workflow Patterns,agent-workflow-patterns,Docs,πŸ“š,Building Effective Agents,https://www.anthropic.com/engineering/building-effective-agents,external,www.anthropic.com,"Anthropic's canonical guide to workflows and agents, including evaluator-optimizer and orchestrator-workers patterns.","Anthropic's canonical guide to workflows and agents, including evaluator-optimizer and orchestrator-workers patterns.","Anthropic's canonical guide to workflows and agents, including evaluator-optimizer and orchestrator-workers patterns.","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.",high,README.md,707,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L707,,Design,design,Specify a loop contract and operating pattern.,delegation,builder,technical-documentation,ok,https://www.anthropic.com/engineering/building-effective-agents,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.",,,,,Anthropic,,,,domain-fallback,,,,,,,,2026-07-17T17:58:18+00:00 ale-0145,Agent Workflow Patterns,agent-workflow-patterns,Paper,πŸ“„,"Harness Engineering for Language Agents: The Harness Layer as Control, Agency, and Runtime",https://www.preprints.org/manuscript/202603.1756,external,www.preprints.org,"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.","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.","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.","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.,medium,README.md,708,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L708,,Design,design,Specify a loop contract and operating pattern.,delegation;verification,researcher;evaluator,research-paper,restricted,https://www.preprints.org/manuscript/202603.1756,,,Chaoyue He; Xin Zhou; Di Wang; Hong Xu; Wei Liu; Chunyan Miao,2026-04-23,2026,Preprints.org,Preprints.org,10.20944/preprints202603.1756.v2,Version 2; the primary source states that this preprint is not peer-reviewed.,,primary-page,,,,,,,,2026-07-17T17:58:18+00:00 ale-0146,Agent Workflow Patterns,agent-workflow-patterns,Blog,πŸ“,How we built our multi-agent research system,https://www.anthropic.com/engineering/multi-agent-research-system,external,www.anthropic.com,"Detailed orchestrator-worker system with planning, memory, subagents, citation passes, and iterative research loops.","Detailed orchestrator-worker system with planning, memory, subagents, citation passes, and iterative research loops.","Detailed orchestrator-worker system with planning, memory, subagents, citation passes, and iterative research loops.","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.",contextual,README.md,709,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L709,,Design,design,Specify a loop contract and operating pattern.,context;delegation,builder,practitioner-analysis,ok,https://www.anthropic.com/engineering/multi-agent-research-system,How we built our multi-agent research system \ Anthropic,On the the engineering challenges and lessons learned from building Claude's Research system,,,,,Anthropic,,,,domain-fallback,,,,,,,,2026-07-17T17:58:18+00:00 @@ -164,22 +164,22 @@ ale-0162,Agent Workflow Patterns,agent-workflow-patterns,Blog,πŸ“,"Old and New ale-0163,Agent Workflow Patterns,agent-workflow-patterns,Paper,πŸ“„,"Harness Handbook: Making Evolving Agent Harnesses Readable,Navigable, and Editable",https://arxiv.org/abs/2607.13285,external,arxiv.org,"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.","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.","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.","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.,medium,README.md,726,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L726,2026-07-17,Design,design,Specify a loop contract and operating pattern.,budget,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.13285,"[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,2026-07-14,2026,arXiv,arXiv,,"29 pages, 6 figures. Project page: https://ruhan-wang.github.io/Harness-Handbook/",cs.AI,arxiv-api,,,,,,,2607.13285,2026-07-17T17:58:18+00:00 ale-0164,Agent Workflow Patterns,agent-workflow-patterns,Paper,πŸ“„,MemoHarness: Agent Harnesses That Learn from Experience,https://arxiv.org/abs/2607.14159,external,arxiv.org,"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.","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.","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.","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.,medium,README.md,727,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L727,2026-07-17,Design,design,Specify a loop contract and operating pattern.,context,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.14159,[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,2026-07-14,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2607.14159,2026-07-17T17:58:18+00:00 ale-0165,Coding-Agent Loop Systems,coding-agent-loop-systems,Tool,🧰,SWE-agent,https://github.com/SWE-agent/SWE-agent,external,github.com,Agent-computer interface and autonomous software engineering agent for repository tasks.,Agent-computer interface and autonomous software engineering agent for repository tasks.,Agent-computer interface and autonomous software engineering agent for repository tasks.,Uses real automated software-engineering systems as evidence for practical loop architectures. Agent-computer interface and autonomous software engineering agent for repository tasks.,Use SWE-agent to choose an implementation surface for repeatable agent work.,"Inspectable GitHub source (19,839 stars; 2,167 forks; MIT license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,736,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L736,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,builder,source-implementation,ok,https://github.com/SWE-agent/SWE-agent,"GitHub - SWE-agent/SWE-agent: SWE-agent takes a GitHub issue and tries to automatically fix it, using your LM of choice. It can also be employed for offensive cybersecurity or competitive coding challenges. [NeurIPS 2024] Β· GitHub","SWE-agent takes a GitHub issue and tries to automatically fix it, using your LM of choice. It can also be employed for offensive cybersecurity or competitive coding challenges. [NeurIPS 2024] - GitHub - SWE-agent/SWE-agent: SWE-agent takes a GitHub issue and tries to automatically fix it, using your LM of choice. It can also be employed for offensive cybersecurity or competitive coding challenges. [NeurIPS 2024]",,2024-04-02,2024,SWE-agent/SWE-agent,GitHub,,,,github-api,SWE-agent/SWE-agent,19839,2167,MIT,2024-04-02T04:09:47Z,2026-07-17T17:03:01Z,,2026-07-17T17:58:18+00:00 -ale-0166,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering,https://arxiv.org/abs/2405.15793,external,arxiv.org,Paper behind SWE-agent and its interface design.,Paper behind SWE-agent and its interface design.,Paper behind SWE-agent and its interface design.,Uses real automated software-engineering systems as evidence for practical loop architectures. Paper behind SWE-agent and its interface design.,Use SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering to choose an implementation surface for repeatable agent work.,Research source arXiv:2405.15793; inspect its method and evaluation before treating results as production evidence.,medium,README.md,737,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L737,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2405.15793,[2405.15793] SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering,"Language model (LM) agents are increasingly being used to automate complicated tasks in digital environments. Just as humans benefit from powerful software applications, such as integrated development environments, for complex tasks like software engineering, we posit that LM agents represent a new category of end users with their own needs and abilities, and would benefit from specially-built interfaces to the software they use. We investigate how interface design affects the performance of language model agents. As a result of this exploration, we introduce SWE-agent: a system that facilitates LM agents to autonomously use computers to solve software engineering tasks. SWE-agent's custom agent-computer interface (ACI) significantly enhances an agent's ability to create and edit code files, navigate entire repositories, and execute tests and other programs. We evaluate SWE-agent on SWE-bench and HumanEvalFix, achieving state-of-the-art performance on both with a pass@1 rate of 12.5% and 87.7%, respectively, far exceeding the previous state-of-the-art achieved with non-interactive LMs. Finally, we provide insight on how the design of the ACI can impact agents' behavior and performance.",John Yang; Carlos E. Jimenez; Alexander Wettig; Kilian Lieret; Shunyu Yao; Karthik Narasimhan; Ofir Press,2024-05-06,2024,arXiv,arXiv,,"Code, data, and demo available at https://swe-agent.com",cs.SE,arxiv-api,,,,,,,2405.15793,2026-07-17T17:58:18+00:00 +ale-0166,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering,https://arxiv.org/abs/2405.15793,external,arxiv.org,Paper behind SWE-agent and its interface design.,Paper behind SWE-agent and its interface design.,Paper behind SWE-agent and its interface design.,Uses real automated software-engineering systems as evidence for practical loop architectures. Paper behind SWE-agent and its interface design.,Use SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering to choose an implementation surface for repeatable agent work.,Research source arXiv:2405.15793; inspect its method and evaluation before treating results as production evidence.,medium,README.md,737,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L737,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,researcher;evaluator,research-paper,ok,https://proceedings.neurips.cc/paper_files/paper/2024/hash/5a7c947568c1b1328ccc5230172e1e7c-Abstract-Conference.html,[2405.15793] SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering,"Language model (LM) agents are increasingly being used to automate complicated tasks in digital environments. Just as humans benefit from powerful software applications, such as integrated development environments, for complex tasks like software engineering, we posit that LM agents represent a new category of end users with their own needs and abilities, and would benefit from specially-built interfaces to the software they use. We investigate how interface design affects the performance of language model agents. As a result of this exploration, we introduce SWE-agent: a system that facilitates LM agents to autonomously use computers to solve software engineering tasks. SWE-agent's custom agent-computer interface (ACI) significantly enhances an agent's ability to create and edit code files, navigate entire repositories, and execute tests and other programs. We evaluate SWE-agent on SWE-bench and HumanEvalFix, achieving state-of-the-art performance on both with a pass@1 rate of 12.5% and 87.7%, respectively, far exceeding the previous state-of-the-art achieved with non-interactive LMs. Finally, we provide insight on how the design of the ACI can impact agents' behavior and performance.",John Yang; Carlos E. Jimenez; Alexander Wettig; Kilian Lieret; Shunyu Yao; Karthik Narasimhan; Ofir Press,2024,2024,Advances in Neural Information Processing Systems 37 (NeurIPS),Neural Information Processing Systems Foundation,10.52202/079017-1601,Published in Advances in Neural Information Processing Systems 37 (NeurIPS); the linked arXiv record remains available for open access.,cs.SE,NeurIPS proceedings and DOI records,,,,,,,2405.15793,2026-07-17T17:58:18+00:00 ale-0167,Coding-Agent Loop Systems,coding-agent-loop-systems,Tool,🧰,mini-SWE-agent,https://mini-swe-agent.com/latest/,external,mini-swe-agent.com,Minimal coding agent that is useful for understanding the core loop without a large framework.,Minimal coding agent that is useful for understanding the core loop without a large framework.,Minimal coding agent that is useful for understanding the core loop without a large framework.,Uses real automated software-engineering systems as evidence for practical loop architectures. Minimal coding agent that is useful for understanding the core loop without a large framework.,Use mini-SWE-agent to choose an implementation surface for repeatable agent work.,"Working implementation, framework, runtime, or repository; signal comes from usable code and ecosystem adoption.",high,README.md,738,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L738,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,builder,implementation,ok,https://mini-swe-agent.com/latest/,Overview - mini-SWE-agent documentation,,,,,,mini-swe-agent.com,,,,domain-fallback,,,,,,,,2026-07-17T17:58:18+00:00 ale-0168,Coding-Agent Loop Systems,coding-agent-loop-systems,Tool,🧰,OpenHands,https://github.com/All-Hands-AI/OpenHands,external,github.com,Open platform for AI software developers as generalist agents.,Open platform for AI software developers as generalist agents.,Open platform for AI software developers as generalist agents.,Uses real automated software-engineering systems as evidence for practical loop architectures. Open platform for AI software developers as generalist agents.,Use OpenHands to choose an implementation surface for repeatable agent work.,"Inspectable GitHub source (81,100 stars; 10,369 forks; NOASSERTION license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,739,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L739,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,builder,source-implementation,ok,https://github.com/OpenHands/OpenHands,GitHub - OpenHands/OpenHands: πŸ™Œ OpenHands: AI-Driven Development Β· GitHub,πŸ™Œ OpenHands: AI-Driven Development. Contribute to OpenHands/OpenHands development by creating an account on GitHub.,,2024-03-13,2024,All-Hands-AI/OpenHands,GitHub,,,,github-api,All-Hands-AI/OpenHands,81100,10369,NOASSERTION,2024-03-13T03:33:31Z,2026-07-17T17:52:44Z,,2026-07-17T17:58:18+00:00 -ale-0169,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,OpenHands: An Open Platform for AI Software Developers as Generalist Agents,https://arxiv.org/abs/2407.16741,external,arxiv.org,"Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.","Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.","Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.","Evaluation data is used as the feedback signal for improving loop behavior. Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.",Use OpenHands: An Open Platform for AI Software Developers as Generalist Agents to choose an implementation surface for repeatable agent work.,Research source arXiv:2407.16741; inspect its method and evaluation before treating results as production evidence.,medium,README.md,740,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L740,,Build,build,"Choose runtimes, tools, and delegation surfaces.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2407.16741,[2407.16741] OpenHands: An Open Platform for AI Software Developers as Generalist Agents,"Software is one of the most powerful tools that we humans have at our disposal; it allows a skilled programmer to interact with the world in complex and profound ways. At the same time, thanks to improvements in large language models (LLMs), there has also been a rapid development in AI agents that interact with and affect change in their surrounding environments. In this paper, we introduce OpenHands (f.k.a. OpenDevin), a platform for the development of powerful and flexible AI agents that interact with the world in similar ways to those of a human developer: by writing code, interacting with a command line, and browsing the web. We describe how the platform allows for the implementation of new agents, safe interaction with sandboxed environments for code execution, coordination between multiple agents, and incorporation of evaluation benchmarks. Based on our currently incorporated benchmarks, we perform an evaluation of agents over 15 challenging tasks, including software engineering (e.g., SWE-BENCH) and web browsing (e.g., WEBARENA), among others. Released under the permissive MIT license, OpenHands is a community project spanning academia and industry with more than 2.1K contributions from over 188 contributors.",Xingyao Wang; Boxuan Li; Yufan Song; Frank F. Xu; Xiangru Tang; Mingchen Zhuge; Jiayi Pan; Yueqi Song; Bowen Li; Jaskirat Singh; Hoang H. Tran; Fuqiang Li; Ren Ma; Mingzhang Zheng; Bill Qian; Yanjun Shao; Niklas Muennighoff; Yizhe Zhang; Binyuan Hui; Junyang Lin; Robert Brennan; Hao Peng; Heng Ji; Graham Neubig,2024-07-23,2024,arXiv,arXiv,,Accepted by ICLR 2025; Code: https://github.com/All-Hands-AI/OpenHands,cs.SE,arxiv-api,,,,,,,2407.16741,2026-07-17T17:58:18+00:00 +ale-0169,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,OpenHands: An Open Platform for AI Software Developers as Generalist Agents,https://arxiv.org/abs/2407.16741,external,arxiv.org,"Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.","Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.","Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.","Evaluation data is used as the feedback signal for improving loop behavior. Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.",Use OpenHands: An Open Platform for AI Software Developers as Generalist Agents to choose an implementation surface for repeatable agent work.,Research source arXiv:2407.16741; inspect its method and evaluation before treating results as production evidence.,medium,README.md,740,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L740,,Build,build,"Choose runtimes, tools, and delegation surfaces.",verification,researcher;evaluator,research-paper,ok,https://proceedings.iclr.cc/paper_files/paper/2025/hash/a4b6ad6b48850c0c331d1259fc66a69c-Abstract-Conference.html,[2407.16741] OpenHands: An Open Platform for AI Software Developers as Generalist Agents,"Software is one of the most powerful tools that we humans have at our disposal; it allows a skilled programmer to interact with the world in complex and profound ways. At the same time, thanks to improvements in large language models (LLMs), there has also been a rapid development in AI agents that interact with and affect change in their surrounding environments. In this paper, we introduce OpenHands (f.k.a. OpenDevin), a platform for the development of powerful and flexible AI agents that interact with the world in similar ways to those of a human developer: by writing code, interacting with a command line, and browsing the web. We describe how the platform allows for the implementation of new agents, safe interaction with sandboxed environments for code execution, coordination between multiple agents, and incorporation of evaluation benchmarks. Based on our currently incorporated benchmarks, we perform an evaluation of agents over 15 challenging tasks, including software engineering (e.g., SWE-BENCH) and web browsing (e.g., WEBARENA), among others. Released under the permissive MIT license, OpenHands is a community project spanning academia and industry with more than 2.1K contributions from over 188 contributors.",Xingyao Wang; Boxuan Li; Yufan Song; Frank F. Xu; Xiangru Tang; Mingchen Zhuge; Jiayi Pan; Yueqi Song; Bowen Li; Jaskirat Singh; Hoang H. Tran; Fuqiang Li; Ren Ma; Mingzhang Zheng; Bill Qian; Yanjun Shao; Niklas Muennighoff; Yizhe Zhang; Binyuan Hui; Junyang Lin; Robert Brennan; Hao Peng; Heng Ji; Graham Neubig,2025,2025,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published in International Conference on Learning Representations (ICLR); the linked arXiv record remains available for open access.,cs.SE,ICLR proceedings record,,,,,,,2407.16741,2026-07-17T17:58:18+00:00 ale-0170,Coding-Agent Loop Systems,coding-agent-loop-systems,Tool,🧰,Agentless,https://github.com/OpenAutoCoder/Agentless,external,github.com,"Workflow-based approach for software issue resolution using localization, repair, and patch validation.","Workflow-based approach for software issue resolution using localization, repair, and patch validation.","Workflow-based approach for software issue resolution using localization, repair, and patch validation.","Uses real automated software-engineering systems as evidence for practical loop architectures. Workflow-based approach for software issue resolution using localization, repair, and patch validation.",Use Agentless to choose an implementation surface for repeatable agent work.,"Inspectable GitHub source (2,083 stars; 235 forks; MIT license; updated 2026-07-16); popularity is context, not proof of reliability.",medium,README.md,741,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L741,,Build,build,"Choose runtimes, tools, and delegation surfaces.",intake,builder,source-implementation,ok,https://github.com/OpenAutoCoder/Agentless,GitHub - OpenAutoCoder/Agentless: Agentless🐱: an agentless approach to automatically solve software development problems Β· GitHub,Agentless🐱: an agentless approach to automatically solve software development problems - OpenAutoCoder/Agentless,,2024-06-30,2024,OpenAutoCoder/Agentless,GitHub,,,,github-api,OpenAutoCoder/Agentless,2083,235,MIT,2024-06-30T23:37:17Z,2026-07-16T06:42:42Z,,2026-07-17T17:58:18+00:00 ale-0171,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,Agentless: Demystifying LLM-based Software Engineering Agents,https://arxiv.org/abs/2407.01489,external,arxiv.org,Useful contrast case: strong results through structured workflow rather than a fully open-ended agent.,Useful contrast case: strong results through structured workflow rather than a fully open-ended agent.,Useful contrast case: strong results through structured workflow rather than a fully open-ended agent.,Uses real automated software-engineering systems as evidence for practical loop architectures. Useful contrast case: strong results through structured workflow rather than a fully open-ended agent.,Use Agentless: Demystifying LLM-based Software Engineering Agents to choose an implementation surface for repeatable agent work.,Research source arXiv:2407.01489; inspect its method and evaluation before treating results as production evidence.,medium,README.md,742,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L742,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2407.01489,[2407.01489] Agentless: Demystifying LLM-based Software Engineering Agents,"Recent advancements in large language models (LLMs) have significantly advanced the automation of software development tasks, including code synthesis, program repair, and test generation. More recently, researchers and industry practitioners have developed various autonomous LLM agents to perform end-to-end software development tasks. These agents are equipped with the ability to use tools, run commands, observe feedback from the environment, and plan for future actions. However, the complexity of these agent-based approaches, together with the limited abilities of current LLMs, raises the following question: Do we really have to employ complex autonomous software agents? To attempt to answer this question, we build Agentless -- an agentless approach to automatically solve software development problems. Compared to the verbose and complex setup of agent-based approaches, Agentless employs a simplistic three-phase process of localization, repair, and patch validation, without letting the LLM decide future actions or operate with complex tools. Our results on the popular SWE-bench Lite benchmark show that surprisingly the simplistic Agentless is able to achieve both the highest performance (32.00%, 96 correct fixes) and low cost ($0.70) compared with all existing open-source software agents! Furthermore, we manually classified the problems in SWE-bench Lite and found problems with exact ground truth patch or insufficient/misleading issue descriptions. As such, we construct SWE-bench Lite-S by excluding such problematic issues to perform more rigorous evaluation and comparison. Our work highlights the current overlooked potential of a simple, interpretable technique in autonomous software development. We hope Agentless will help reset the baseline, starting point, and horizon for autonomous software agents, and inspire future work along this crucial direction.",Chunqiu Steven Xia; Yinlin Deng; Soren Dunn; Lingming Zhang,2024-07-01,2024,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2407.01489,2026-07-17T17:58:18+00:00 ale-0172,Coding-Agent Loop Systems,coding-agent-loop-systems,Tool,🧰,AutoCodeRover,https://github.com/AutoCodeRoverSG/auto-code-rover,external,github.com,"Autonomous program improvement system for issue localization, patch generation, and validation.","Autonomous program improvement system for issue localization, patch generation, and validation.","Autonomous program improvement system for issue localization, patch generation, and validation.","Uses real automated software-engineering systems as evidence for practical loop architectures. Autonomous program improvement system for issue localization, patch generation, and validation.",Use AutoCodeRover to choose an implementation surface for repeatable agent work.,"Inspectable GitHub source (3,096 stars; 334 forks; NOASSERTION license; updated 2026-07-14); popularity is context, not proof of reliability.",medium,README.md,743,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L743,,Build,build,"Choose runtimes, tools, and delegation surfaces.",intake,builder,source-implementation,ok,https://github.com/AutoCodeRoverSG/auto-code-rover,GitHub - AutoCodeRoverSG/auto-code-rover: A project structure aware autonomous software engineer aiming for autonomous program improvement. Resolved 37.3% tasks (pass@1) in SWE-bench lite and 46.2% tasks (pass@1) in SWE-bench verified with each task costs less than $0.7. Β· GitHub,A project structure aware autonomous software engineer aiming for autonomous program improvement. Resolved 37.3% tasks (pass@1) in SWE-bench lite and 46.2% tasks (pass@1) in SWE-bench verified with each task costs less than $0.7. - AutoCodeRoverSG/auto-code-rover,,2024-04-08,2024,AutoCodeRoverSG/auto-code-rover,GitHub,,,,github-api,AutoCodeRoverSG/auto-code-rover,3096,334,NOASSERTION,2024-04-08T05:34:14Z,2026-07-14T08:02:04Z,,2026-07-17T17:58:18+00:00 -ale-0173,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,AutoCodeRover: Autonomous Program Improvement,https://arxiv.org/abs/2404.05427,external,arxiv.org,Paper on autonomous code repair loops over real repositories.,Paper on autonomous code repair loops over real repositories.,Paper on autonomous code repair loops over real repositories.,Uses real automated software-engineering systems as evidence for practical loop architectures. Paper on autonomous code repair loops over real repositories.,Use AutoCodeRover: Autonomous Program Improvement to choose an implementation surface for repeatable agent work.,Research source arXiv:2404.05427; inspect its method and evaluation before treating results as production evidence.,medium,README.md,744,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L744,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2404.05427,[2404.05427] AutoCodeRover: Autonomous Program Improvement,"Researchers have made significant progress in automating the software development process in the past decades. Recent progress in Large Language Models (LLMs) has significantly impacted the development process, where developers can use LLM-based programming assistants to achieve automated coding. Nevertheless, software engineering involves the process of program improvement apart from coding, specifically to enable software maintenance (e.g. bug fixing) and software evolution (e.g. feature additions). In this paper, we propose an automated approach for solving GitHub issues to autonomously achieve program improvement. In our approach called AutoCodeRover, LLMs are combined with sophisticated code search capabilities, ultimately leading to a program modification or patch. In contrast to recent LLM agent approaches from AI researchers and practitioners, our outlook is more software engineering oriented. We work on a program representation (abstract syntax tree) as opposed to viewing a software project as a mere collection of files. Our code search exploits the program structure in the form of classes/methods to enhance LLM's understanding of the issue's root cause, and effectively retrieve a context via iterative search. The use of spectrum-based fault localization using tests, further sharpens the context, as long as a test-suite is available. Experiments on SWE-bench-lite (300 real-life GitHub issues) show increased efficacy in solving GitHub issues (19% on SWE-bench-lite), which is higher than the efficacy of the recently reported SWE-agent. In addition, AutoCodeRover achieved this efficacy with significantly lower cost (on average, $0.43 USD), compared to other baselines. We posit that our workflow enables autonomous software engineering, where, in future, auto-generated code from LLMs can be autonomously improved.",Yuntong Zhang; Haifeng Ruan; Zhiyu Fan; Abhik Roychoudhury,2024-04-08,2024,arXiv,arXiv,,To appear in ISSTA 2024,cs.SE,arxiv-api,,,,,,,2404.05427,2026-07-17T17:58:18+00:00 +ale-0173,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,AutoCodeRover: Autonomous Program Improvement,https://arxiv.org/abs/2404.05427,external,arxiv.org,Paper on autonomous code repair loops over real repositories.,Paper on autonomous code repair loops over real repositories.,Paper on autonomous code repair loops over real repositories.,Uses real automated software-engineering systems as evidence for practical loop architectures. Paper on autonomous code repair loops over real repositories.,Use AutoCodeRover: Autonomous Program Improvement to choose an implementation surface for repeatable agent work.,Research source arXiv:2404.05427; inspect its method and evaluation before treating results as production evidence.,medium,README.md,744,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L744,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,researcher;evaluator,research-paper,ok,https://doi.org/10.1145/3650212.3680384,[2404.05427] AutoCodeRover: Autonomous Program Improvement,"Researchers have made significant progress in automating the software development process in the past decades. Recent progress in Large Language Models (LLMs) has significantly impacted the development process, where developers can use LLM-based programming assistants to achieve automated coding. Nevertheless, software engineering involves the process of program improvement apart from coding, specifically to enable software maintenance (e.g. bug fixing) and software evolution (e.g. feature additions). In this paper, we propose an automated approach for solving GitHub issues to autonomously achieve program improvement. In our approach called AutoCodeRover, LLMs are combined with sophisticated code search capabilities, ultimately leading to a program modification or patch. In contrast to recent LLM agent approaches from AI researchers and practitioners, our outlook is more software engineering oriented. We work on a program representation (abstract syntax tree) as opposed to viewing a software project as a mere collection of files. Our code search exploits the program structure in the form of classes/methods to enhance LLM's understanding of the issue's root cause, and effectively retrieve a context via iterative search. The use of spectrum-based fault localization using tests, further sharpens the context, as long as a test-suite is available. Experiments on SWE-bench-lite (300 real-life GitHub issues) show increased efficacy in solving GitHub issues (19% on SWE-bench-lite), which is higher than the efficacy of the recently reported SWE-agent. In addition, AutoCodeRover achieved this efficacy with significantly lower cost (on average, $0.43 USD), compared to other baselines. We posit that our workflow enables autonomous software engineering, where, in future, auto-generated code from LLMs can be autonomously improved.",Yuntong Zhang; Haifeng Ruan; Zhiyu Fan; Abhik Roychoudhury,2024-09-11,2024,Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA),Association for Computing Machinery,10.1145/3650212.3680384,Published in Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA); the linked arXiv record remains available for open access.,cs.SE,ACM DOI record,,,,,,,2404.05427,2026-07-17T17:58:18+00:00 ale-0174,Coding-Agent Loop Systems,coding-agent-loop-systems,List,🧭,SWE-bench reading list,https://github.com/SWE-bench/reading-list,external,github.com,Maintained map of software engineering agent systems and related papers.,Maintained map of software engineering agent systems and related papers.,Maintained map of software engineering agent systems and related papers.,Uses real automated software-engineering systems as evidence for practical loop architectures. Maintained map of software engineering agent systems and related papers.,Use SWE-bench reading list to choose an implementation surface for repeatable agent work.,"Inspectable GitHub source (15 stars; 4 forks; updated 2026-06-30); popularity is context, not proof of reliability.",medium,README.md,745,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L745,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,builder,curated-index,ok,https://github.com/SWE-bench/reading-list,GitHub - SWE-bench/reading-list: Academic papers and works related to SWE-bench and SWE-agents Β· GitHub,Academic papers and works related to SWE-bench and SWE-agents - SWE-bench/reading-list,,2025-06-26,2025,SWE-bench/reading-list,GitHub,,,,github-api,SWE-bench/reading-list,15,4,,2025-06-26T22:03:02Z,2026-06-30T13:06:47Z,,2026-07-17T17:58:18+00:00 -ale-0175,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,TraceCoder: A Trace-Driven Multi-Agent Framework for Automated Debugging of LLM-Generated Code,https://arxiv.org/abs/2602.06875,external,arxiv.org,"ICSE'26 observe-analyze-repair loop with instrumentation, analysis, and repair agents, a history-learning mechanism, and a rollback to the last good state; iteration alone drives most of the gain.","ICSE'26 observe-analyze-repair loop with instrumentation, analysis, and repair agents, a history-learning mechanism, and a rollback to the last good state; iteration alone drives most of the gain.","ICSE'26 observe-analyze-repair loop with instrumentation, analysis, and repair agents, a history-learning mechanism, and a rollback to the last good state; iteration alone drives most of the gain.","The work separates roles across agents, verifiers, or orchestration layers. ICSE'26 observe-analyze-repair loop with instrumentation, analysis, and repair agents, a history-learning mechanism, and a rollback to the last good state; iteration alone drives most of the gain.",Use TraceCoder: A Trace-Driven Multi-Agent Framework for Automated Debugging of LLM-Generated Code to choose an implementation surface for repeatable agent work.,Research source arXiv:2602.06875; inspect its method and evaluation before treating results as production evidence.,medium,README.md,746,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L746,,Build,build,"Choose runtimes, tools, and delegation surfaces.",delegation;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2602.06875,[2602.06875] TraceCoder: A Trace-Driven Multi-Agent Framework for Automated Debugging of LLM-Generated Code,"Large Language Models (LLMs) often generate code with subtle but critical bugs, especially for complex tasks. Existing automated repair methods typically rely on superficial pass/fail signals, offering limited visibility into program behavior and hindering precise error localization. In addition, without a way to learn from prior failures, repair processes often fall into repetitive and inefficient cycles. To overcome these challenges, we present TraceCoder, a collaborative multi-agent framework that emulates the observe-analyze-repair process of human experts. The framework first instruments the code with diagnostic probes to capture fine-grained runtime traces, enabling deep insight into its internal execution. It then conducts causal analysis on these traces to accurately identify the root cause of the failure. This process is further enhanced by a novel Historical Lesson Learning Mechanism (HLLM), which distills insights from prior failed repair attempts to inform subsequent correction strategies and prevent recurrence of similar mistakes. To ensure stable convergence, a Rollback Mechanism enforces that each repair iteration constitutes a strict improvement toward the correct solution. Comprehensive experiments across multiple benchmarks show that TraceCoder achieves up to a 34.43\% relative improvement in Pass@1 accuracy over existing advanced baselines. Ablation studies verify the significance of each system component, with the iterative repair process alone contributing a 65.61\% relative gain in accuracy. Furthermore, TraceCoder significantly outperforms leading iterative methods in terms of both accuracy and cost-efficiency.",Jiangping Huang; Wenguang Ye; Weisong Sun; Jian Zhang; Mingyue Zhang; Yang Liu,2026-02-06,2026,arXiv,arXiv,10.1145/3744916.3773187,,cs.SE,arxiv-api,,,,,,,2602.06875,2026-07-17T17:58:18+00:00 +ale-0175,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,TraceCoder: A Trace-Driven Multi-Agent Framework for Automated Debugging of LLM-Generated Code,https://arxiv.org/abs/2602.06875,external,arxiv.org,"ICSE'26 observe-analyze-repair loop with instrumentation, analysis, and repair agents, a history-learning mechanism, and a rollback to the last good state; iteration alone drives most of the gain.","ICSE'26 observe-analyze-repair loop with instrumentation, analysis, and repair agents, a history-learning mechanism, and a rollback to the last good state; iteration alone drives most of the gain.","ICSE'26 observe-analyze-repair loop with instrumentation, analysis, and repair agents, a history-learning mechanism, and a rollback to the last good state; iteration alone drives most of the gain.","The work separates roles across agents, verifiers, or orchestration layers. ICSE'26 observe-analyze-repair loop with instrumentation, analysis, and repair agents, a history-learning mechanism, and a rollback to the last good state; iteration alone drives most of the gain.",Use TraceCoder: A Trace-Driven Multi-Agent Framework for Automated Debugging of LLM-Generated Code to choose an implementation surface for repeatable agent work.,Research source arXiv:2602.06875; inspect its method and evaluation before treating results as production evidence.,medium,README.md,746,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L746,,Build,build,"Choose runtimes, tools, and delegation surfaces.",delegation;state,researcher;evaluator,research-paper,ok,https://conf.researchr.org/details/icse-2026/icse-2026-research-track/145/TraceCoder-A-Trace-Driven-Multi-Agent-Framework-for-Automated-Debugging-of-LLM-Gener,[2602.06875] TraceCoder: A Trace-Driven Multi-Agent Framework for Automated Debugging of LLM-Generated Code,"Large Language Models (LLMs) often generate code with subtle but critical bugs, especially for complex tasks. Existing automated repair methods typically rely on superficial pass/fail signals, offering limited visibility into program behavior and hindering precise error localization. In addition, without a way to learn from prior failures, repair processes often fall into repetitive and inefficient cycles. To overcome these challenges, we present TraceCoder, a collaborative multi-agent framework that emulates the observe-analyze-repair process of human experts. The framework first instruments the code with diagnostic probes to capture fine-grained runtime traces, enabling deep insight into its internal execution. It then conducts causal analysis on these traces to accurately identify the root cause of the failure. This process is further enhanced by a novel Historical Lesson Learning Mechanism (HLLM), which distills insights from prior failed repair attempts to inform subsequent correction strategies and prevent recurrence of similar mistakes. To ensure stable convergence, a Rollback Mechanism enforces that each repair iteration constitutes a strict improvement toward the correct solution. Comprehensive experiments across multiple benchmarks show that TraceCoder achieves up to a 34.43\% relative improvement in Pass@1 accuracy over existing advanced baselines. Ablation studies verify the significance of each system component, with the iterative repair process alone contributing a 65.61\% relative gain in accuracy. Furthermore, TraceCoder significantly outperforms leading iterative methods in terms of both accuracy and cost-efficiency.",Jiangping Huang; Wenguang Ye; Weisong Sun; Jian Zhang; Mingyue Zhang; Yang Liu,2026-04-12,2026,Proceedings of the 48th IEEE/ACM International Conference on Software Engineering (ICSE),Association for Computing Machinery,10.1145/3744916.3773187,Published in Proceedings of the 48th IEEE/ACM International Conference on Software Engineering (ICSE); the linked arXiv record remains available for open access.,cs.SE,ICSE program and camera-ready records,,,,,,,2602.06875,2026-07-17T17:58:18+00:00 ale-0176,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,The Kitchen Loop: User-Spec-Driven Development for a Self-Evolving Codebase,https://arxiv.org/abs/2603.25697,external,arxiv.org,"Production loop where an agent exercises a spec surface as a synthetic power user behind ground-truth tests and quality gates, reporting 285+ self-correcting iterations and 1,000+ merged PRs with zero detected regressions.","Production loop where an agent exercises a spec surface as a synthetic power user behind ground-truth tests and quality gates, reporting 285+ self-correcting iterations and 1,000+ merged PRs with zero detected regressions.","Production loop where an agent exercises a spec surface as a synthetic power user behind ground-truth tests and quality gates, reporting 285+ self-correcting iterations and 1,000+ merged PRs with zero detected regressions.","Uses real automated software-engineering systems as evidence for practical loop architectures. Production loop where an agent exercises a spec surface as a synthetic power user behind ground-truth tests and quality gates, reporting 285+ self-correcting iterations and 1,000+ merged PRs with zero detected regressions.",Use The Kitchen Loop: User-Spec-Driven Development for a Self-Evolving Codebase to choose an implementation surface for repeatable agent work.,Research source arXiv:2603.25697; inspect its method and evaluation before treating results as production evidence.,medium,README.md,747,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L747,,Build,build,"Choose runtimes, tools, and delegation surfaces.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2603.25697,[2603.25697] The Kitchen Loop: User-Spec-Driven Development for a Self-Evolving Codebase,"Code production is now a commodity; the bottleneck is knowing what to build and proving it works. We present the Kitchen Loop, a framework for autonomous, self-evolving software built on a unified trust model: (1) a specification surface enumerating what the product claims to support; (2) 'As a User x 1000', where an LLM agent exercises that surface as a synthetic power user at 1,000x human cadence; (3) Unbeatable Tests, ground-truth verification the code author cannot fake; and (4) Drift Control, continuous quality measurement with automated pause gates. We validate across two production systems over 285+ iterations, producing 1,094+ merged pull requests with zero regressions detected by the regression oracle (methodology in Section 6.1). We observe emergent properties at scale: multi-iteration self-correction chains, autonomous infrastructure healing, and monotonically improving quality gates. The primitives are not new; our contribution is their composition into a production-tested system with the operational discipline that makes long-running autonomous evolution safe.",Yannick Roy,2026-03-26,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2603.25697,2026-07-17T17:58:18+00:00 ale-0177,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,Inside the Scaffold: A Source-Code Taxonomy of Coding Agent Architectures,https://arxiv.org/abs/2604.03515,external,arxiv.org,"Dissects 13 open-source coding-agent scaffolds and identifies five composable loop primitives (ReAct, generate-test-repair, plan-execute, retry, tree search) that real agents layer, mapping how control loop, tools, and state combine.","Dissects 13 open-source coding-agent scaffolds and identifies five composable loop primitives (ReAct, generate-test-repair, plan-execute, retry, tree search) that real agents layer, mapping how control loop, tools, and state combine.","Dissects 13 open-source coding-agent scaffolds and identifies five composable loop primitives (ReAct, generate-test-repair, plan-execute, retry, tree search) that real agents layer, mapping how control loop, tools, and state combine.","State persistence is explicit enough for repeated runs and handoff. Dissects 13 open-source coding-agent scaffolds and identifies five composable loop primitives (ReAct, generate-test-repair, plan-execute, retry, tree search) that real agents layer, mapping how control loop, tools, and state combine.",Use Inside the Scaffold: A Source-Code Taxonomy of Coding Agent Architectures to choose an implementation surface for repeatable agent work.,Research source arXiv:2604.03515; inspect its method and evaluation before treating results as production evidence.,medium,README.md,748,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L748,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;verification;state;budget,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2604.03515,[2604.03515] Inside the Scaffold: A Source-Code Taxonomy of Coding Agent Architectures,"LLM-based coding agents can localize bugs, generate patches, and run tests with diminishing human oversight, yet the scaffolding code that surrounds the language model (the control loop, tool definitions, state management, and context strategy) remains poorly understood. Existing surveys classify agents by abstract capabilities (tool use, planning, reflection) that cannot distinguish between architecturally distinct systems, and trajectory studies observe what agents do without examining the scaffold code that determines why. This paper presents a source-code-level architectural taxonomy derived from analysis of 13 open-source coding agent scaffolds at pinned commit hashes. Each agent is characterized across 12 dimensions organized into three layers: control architecture, tool and environment interface, and resource management. The analysis reveals that scaffold architectures resist discrete classification: control strategies range from fixed pipelines to Monte Carlo Tree Search, tool counts range from 0 to 37, and context compaction spans seven distinct strategies. Five loop primitives (ReAct, generate-test-repair, plan-execute, multi-attempt retry, tree search) function as composable building blocks that agents layer in different combinations; 11 of 13 agents compose multiple primitives rather than relying on a single control structure. Dimensions converge where external constraints dominate (tool capability categories, edit formats, execution isolation) and diverge where open design questions remain (context compaction, state management, multi-model routing). All taxonomic claims are grounded in file paths and line numbers, providing a reusable reference for researchers studying agent behavior and practitioners designing new scaffolds.",Benjamin Rombaut,2026-04-03,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2604.03515,2026-07-17T17:58:18+00:00 ale-0178,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,A Self-Improving Coding Agent,https://arxiv.org/abs/2504.15228,external,arxiv.org,"An agent that edits its own code and tools and re-runs against a benchmark, lifting itself from 17% to 53% on a SWE-bench Verified subset, a concrete self-modifying improvement loop.","An agent that edits its own code and tools and re-runs against a benchmark, lifting itself from 17% to 53% on a SWE-bench Verified subset, a concrete self-modifying improvement loop.","An agent that edits its own code and tools and re-runs against a benchmark, lifting itself from 17% to 53% on a SWE-bench Verified subset, a concrete self-modifying improvement loop.","Verification is promoted from a final check to a loop-control signal. An agent that edits its own code and tools and re-runs against a benchmark, lifting itself from 17% to 53% on a SWE-bench Verified subset, a concrete self-modifying improvement loop.",Use A Self-Improving Coding Agent to choose an implementation surface for repeatable agent work.,Research source arXiv:2504.15228; inspect its method and evaluation before treating results as production evidence.,medium,README.md,749,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L749,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2504.15228,[2504.15228] A Self-Improving Coding Agent,"Recent advancements in Large Language Models (LLMs) have spurred interest in deploying LLM agents to undertake tasks in the world. LLMs are often deployed in agent systems: code that orchestrates LLM calls and provides them with tools. We demonstrate that an agent system, equipped with basic coding tools, can autonomously edit itself, and thereby improve its performance on benchmark tasks. We find performance gains from 17% to 53% on a random subset of SWE Bench Verified, with additional performance gains on LiveCodeBench, as well as synthetically generated agent benchmarks. Our work represents an advancement in the automated and open-ended design of agentic systems, and demonstrates a data-efficient, non gradient-based learning mechanism driven by LLM reflection and code updates.",Maxime Robeyns; Martin Szummer; Laurence Aitchison,2025-04-21,2025,arXiv,arXiv,,Submitted as a preprint to NeurIPS 2025,cs.AI,arxiv-api,,,,,,,2504.15228,2026-07-17T17:58:18+00:00 ale-0179,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,Don't Blame the Large Language Model: How Scaffolding Evolution Shapes Coding Agent Quality,https://arxiv.org/abs/2607.03691,external,arxiv.org,"Longitudinal study of 35 Qwen Code CLI releases with the model held constant, tracing coding-agent shifts to specific scaffolding changes in system prompts, tools, context management, and reasoning loops, and separating scaffolding regressions from model regressions.","Longitudinal study of 35 Qwen Code CLI releases with the model held constant, tracing coding-agent shifts to specific scaffolding changes in system prompts, tools, context management, and reasoning loops, and separating scaffolding regressions from model regressions.","Longitudinal study of 35 Qwen Code CLI releases with the model held constant, tracing coding-agent shifts to specific scaffolding changes in system prompts, tools, context management, and reasoning loops, and separating scaffolding regressions from model regressions.","Context is managed as durable loop state rather than a single prompt payload. Longitudinal study of 35 Qwen Code CLI releases with the model held constant, tracing coding-agent shifts to specific scaffolding changes in system prompts, tools, context management, and reasoning loops, and separating scaffolding regressions from model regressions.",Use Don't Blame the Large Language Model: How Scaffolding Evolution Shapes Coding Agent Quality to choose an implementation surface for repeatable agent work.,Research source arXiv:2607.03691; inspect its method and evaluation before treating results as production evidence.,medium,README.md,750,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L750,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;context,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.03691,[2607.03691] Don't Blame the Large Language Model: How Scaffolding Evolution Shapes Coding Agent Quality,"Coding agents, autonomous systems that use large language models (LLMs) to resolve software engineering tasks, rely on agentic scaffolding: a middleware layer in between a developer and a large language model that orchestrates system prompts, tool execution, context management, and iterative reasoning loops. While these scaffoldings evolve at extreme velocities, no study has examined how this evolution affects agent quality (i.e., effectiveness and efficiency) over time. Practitioners regularly report quality regressions after scaffolding updates, yet consistently attribute them to the underlying model rather than the scaffolding itself. In this paper, we address this gap by conducting the first controlled longitudinal study that isolates the scaffolding's contribution. Unlike prior work that fixes the scaffolding and varies the model, we fix the model and vary only the scaffolding, evaluating 35 sequential releases to measure their impact on agent effectiveness and efficiency. We first empirically study the development and release evolution of five major open-source scaffoldings (i.e., Codex, Qwen Code, Gemini, OpenCode, and OpenHands), revealing extreme release velocities exceeding two releases per day and thousands of issues within months. We then perform a controlled deep dive into 35 sequential releases of the Qwen Code CLI, evaluating each against 50 stratified SWE-bench Verified tasks while holding the underlying LLM constant. We trace the resulting quality fluctuations to specific development patterns and architectural components, and illustrate our findings with concrete qualitative evidence linking individual pull requests to measured quality shifts.",Oussama Ben Sghaier; Hao Li; Bram Adams; Ahmed E. Hassan,2026-07-04,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.03691,2026-07-17T17:58:18+00:00 ale-0180,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,"ToFu: A White-Box, Token-Efficient Agent Harness for Researchers",https://arxiv.org/abs/2607.11423,external,arxiv.org,"MIT-licensed white-box agent harness built on the thesis that agent behavior is set by the orchestration code around the model as much as the model itself, letting researchers inspect, modify, and evaluate its orchestration logic with reported token-efficiency gains over existing harnesses.","MIT-licensed white-box agent harness built on the thesis that agent behavior is set by the orchestration code around the model as much as the model itself, letting researchers inspect, modify, and evaluate its orchestration logic with reported token-efficiency gains over existing harnesses.","MIT-licensed white-box agent harness built on the thesis that agent behavior is set by the orchestration code around the model as much as the model itself, letting researchers inspect, modify, and evaluate its orchestration logic with reported token-efficiency gains over existing harnesses.","Orchestration and control flow are made explicit and inspectable. MIT-licensed white-box agent harness built on the thesis that agent behavior is set by the orchestration code around the model as much as the model itself, letting researchers inspect, modify, and evaluate its orchestration logic with reported token-efficiency gains over existing harnesses.","Use ToFu: A White-Box, Token-Efficient Agent Harness for Researchers to choose an implementation surface for repeatable agent work.",Research source arXiv:2607.11423; inspect its method and evaluation before treating results as production evidence.,medium,README.md,751,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L751,2026-07-15,Build,build,"Choose runtimes, tools, and delegation surfaces.",delegation;budget,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.11423,"[2607.11423] ToFu: A White-Box, Token-Efficient Agent Harness for Researchers","Agentic coding tools present new opportunities to transform research workflows. The performance of agent systems built depends on both large language models (LLMs) and the harness around LLMs, which is the orchestration code that determines an agent's behavior. We present ToFu, an agentic harness for researchers that reads your codebase, edits files, runs commands, and integrates with your development tools. ToFu plays a dual role in research. As a research assistant, it supports practical research workflows with superior token efficiency, lower cost, and multilingual capability compared with existing agentic harnesses. Its release under the MIT License further enables local deployment for privacy-sensitive users. As a research object, ToFu provides a white-box agentic harness that allows researchers to inspect, modify, and evaluate its orchestration logic, tool-use behavior, and harness design, while retaining strong benchmark performance and an application-level user experience.",Junhao Ruan; Yuan Ge; Bei Li; Yongjing Yin; Yuchun Fan; Xin Chen; Jingang Wang; Chenglong Wang; Jingbo Zhu; Tong Xiao,2026-07-13,2026,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,2607.11423,2026-07-17T17:58:18+00:00 -ale-0181,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,When Does Restricting a Coding Agent to execute_code Help?,https://arxiv.org/abs/2607.10569,external,arxiv.org,"Regime-by-design ablation measuring when constraining a coding agent to a single execute_code action helps or hurts, separating task regime from agent design so harness choices can be made from evidence rather than intuition.","Regime-by-design ablation measuring when constraining a coding agent to a single execute_code action helps or hurts, separating task regime from agent design so harness choices can be made from evidence rather than intuition.","Regime-by-design ablation measuring when constraining a coding agent to a single execute_code action helps or hurts, separating task regime from agent design so harness choices can be made from evidence rather than intuition.","Uses real automated software-engineering systems as evidence for practical loop architectures. Regime-by-design ablation measuring when constraining a coding agent to a single execute_code action helps or hurts, separating task regime from agent design so harness choices can be made from evidence rather than intuition.",Use When Does Restricting a Coding Agent to execute_code Help? to choose an implementation surface for repeatable agent work.,Research source arXiv:2607.10569; inspect its method and evaluation before treating results as production evidence.,medium,README.md,752,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L752,2026-07-15,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.10569,[2607.10569] When Does Restricting a Coding Agent to execute_code Help? A Regime $\times$ Agent-Design Ablation,"Modern coding agents expose multiple tool surfaces -- IDE primitives, bash, and Model Context Protocol (MCP) code-execution -- and the field has shipped three contradictory claims about which one matters. We run the missing crossed comparison: an integrity-clean three-arm ablation (baseline / bash_only / code_only) on synthetic computation tasks and SWE-bench Mini modification tasks, holding model, harness, and prompts fixed, with two agents (Claude Code, OpenAI Codex CLI) so the comparison spans both regime and agent-design axes. Across the four resulting (regime, agent) cells, restricting the agent to a single execute_code MCP tool is cheaper than -- or statistically tied with -- its cheapest tool-rich rival in three cells (significantly on Artifact/Claude and SWE-bench/Codex; directionally on Artifact/Codex), with pass rates statistically tied within each cell. The lone exception is SWE-bench/Claude, where code_only is directionally costlier (+14.4%, not significant); a conditional-cost analysis localizes that gap to failure-cost on doomed-run trajectories, not a per-edit tax on successful runs. Two implications: the cheapest tool surface is jointly determined by task regime and agent design rather than by either axis alone, and the headline cost signal lives in cache-adjusted cost -- not pass rate, which is invariant across surfaces at the model sizes we evaluate. The benchmark harness, task suite, and analysis code are available at https://github.com/hyang0129/onlycodes.",Hong Yang; Qi Yu; Travis Desell,2026-07-12,2026,arXiv,arXiv,,"9 pages (excluding references), 4 figures, 4 tables. Accepted to the Agentic Software Engineering (SE 3.0) Workshop at KDD 2026 (non-archival)",cs.SE,arxiv-api,,,,,,,2607.10569,2026-07-17T17:58:18+00:00 +ale-0181,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,When Does Restricting a Coding Agent to execute_code Help?,https://arxiv.org/abs/2607.10569,external,arxiv.org,"Regime-by-design ablation measuring when constraining a coding agent to a single execute_code action helps or hurts, separating task regime from agent design so harness choices can be made from evidence rather than intuition.","Regime-by-design ablation measuring when constraining a coding agent to a single execute_code action helps or hurts, separating task regime from agent design so harness choices can be made from evidence rather than intuition.","Regime-by-design ablation measuring when constraining a coding agent to a single execute_code action helps or hurts, separating task regime from agent design so harness choices can be made from evidence rather than intuition.","Uses real automated software-engineering systems as evidence for practical loop architectures. Regime-by-design ablation measuring when constraining a coding agent to a single execute_code action helps or hurts, separating task regime from agent design so harness choices can be made from evidence rather than intuition.",Use When Does Restricting a Coding Agent to execute_code Help? to choose an implementation surface for repeatable agent work.,Research source arXiv:2607.10569; inspect its method and evaluation before treating results as production evidence.,medium,README.md,752,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L752,2026-07-15,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,researcher;evaluator,research-paper,ok,https://arxiv.org/abs/2607.10569,[2607.10569] When Does Restricting a Coding Agent to execute_code Help? A Regime $\times$ Agent-Design Ablation,"Modern coding agents expose multiple tool surfaces -- IDE primitives, bash, and Model Context Protocol (MCP) code-execution -- and the field has shipped three contradictory claims about which one matters. We run the missing crossed comparison: an integrity-clean three-arm ablation (baseline / bash_only / code_only) on synthetic computation tasks and SWE-bench Mini modification tasks, holding model, harness, and prompts fixed, with two agents (Claude Code, OpenAI Codex CLI) so the comparison spans both regime and agent-design axes. Across the four resulting (regime, agent) cells, restricting the agent to a single execute_code MCP tool is cheaper than -- or statistically tied with -- its cheapest tool-rich rival in three cells (significantly on Artifact/Claude and SWE-bench/Codex; directionally on Artifact/Codex), with pass rates statistically tied within each cell. The lone exception is SWE-bench/Claude, where code_only is directionally costlier (+14.4%, not significant); a conditional-cost analysis localizes that gap to failure-cost on doomed-run trajectories, not a per-edit tax on successful runs. Two implications: the cheapest tool surface is jointly determined by task regime and agent design rather than by either axis alone, and the headline cost signal lives in cache-adjusted cost -- not pass rate, which is invariant across surfaces at the model sizes we evaluate. The benchmark harness, task suite, and analysis code are available at https://github.com/hyang0129/onlycodes.",Hong Yang; Qi Yu; Travis Desell,2026,2026,KDD Workshop on Agentic Software Engineering (SE 3.0),ACM SIGKDD,,Accepted at KDD Workshop on Agentic Software Engineering (SE 3.0); the linked arXiv record is the available paper version.,cs.SE,Current arXiv acceptance note and official non-archival workshop page,,,,,,,2607.10569,2026-07-17T17:58:18+00:00 ale-0182,Coding-Agent Loop Systems,coding-agent-loop-systems,Pattern,πŸ”,Ralph,https://ghuntley.com/ralph/,external,ghuntley.com,Geoffrey Huntley's original Ralph technique: run one agent in a bare loop with fresh context per iteration and the filesystem plus specs as memory.,Geoffrey Huntley's original Ralph technique: run one agent in a bare loop with fresh context per iteration and the filesystem plus specs as memory.,Geoffrey Huntley's original Ralph technique: run one agent in a bare loop with fresh context per iteration and the filesystem plus specs as memory.,Persistent memory is treated as an external runtime artifact. Geoffrey Huntley's original Ralph technique: run one agent in a bare loop with fresh context per iteration and the filesystem plus specs as memory.,Use Ralph to choose an implementation surface for repeatable agent work.,Operational pattern or playbook; signal comes from reusable loop structure and practical transferability.,medium,README.md,757,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L757,,Build,build,"Choose runtimes, tools, and delegation surfaces.",context,builder,operational-pattern,ok,https://ghuntley.com/ralph/,"Ralph Wiggum as a ""software engineer""","How Ralph Wiggum went from 'The Simpsons' to the biggest name in AI right now - Venture Beat 😎Here's a cool little field report from a Y Combinator hackathon event where they put Ralph Wiggum to the test. ""We Put a Coding Agent in a While Loop and It Shipped",,2025-07-14,2025,,Geoffrey Huntley,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0183,Coding-Agent Loop Systems,coding-agent-loop-systems,Pattern,πŸ”,everything is a ralph loop,https://ghuntley.com/loop/,external,ghuntley.com,"Follow-up essay arguing the loop, not the agent, is the durable engineering unit: one task per iteration, deterministic context, and verification inside the loop.","Follow-up essay arguing the loop, not the agent, is the durable engineering unit: one task per iteration, deterministic context, and verification inside the loop.","Follow-up essay arguing the loop, not the agent, is the durable engineering unit: one task per iteration, deterministic context, and verification inside the loop.","Durable execution and replay are treated as first-class loop infrastructure. Follow-up essay arguing the loop, not the agent, is the durable engineering unit: one task per iteration, deterministic context, and verification inside the loop.",Use everything is a ralph loop to choose an implementation surface for repeatable agent work.,Operational pattern or playbook; signal comes from reusable loop structure and practical transferability.,medium,README.md,758,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L758,,Build,build,"Choose runtimes, tools, and delegation surfaces.",context;verification,builder,operational-pattern,ok,https://ghuntley.com/loop/,everything is a ralph loop,"I’ve been thinking about how I build software is so very very different how I used to do it three years ago. No, I’m not talking about acceleration through usage of AI but instead at a more fundamental level of approach, techniques and best practices. Standard software practices",,2026-01-17,2026,,Geoffrey Huntley,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0184,Coding-Agent Loop Systems,coding-agent-loop-systems,Tool,🧰,how-to-ralph-wiggum,https://github.com/ghuntley/how-to-ralph-wiggum,external,github.com,"Reference repository documenting the Ralph Wiggum technique end to end, from the bare loop script to guardrails and conventions.","Reference repository documenting the Ralph Wiggum technique end to end, from the bare loop script to guardrails and conventions.","Reference repository documenting the Ralph Wiggum technique end to end, from the bare loop script to guardrails and conventions.","Uses real automated software-engineering systems as evidence for practical loop architectures. Reference repository documenting the Ralph Wiggum technique end to end, from the bare loop script to guardrails and conventions.",Use how-to-ralph-wiggum to choose an implementation surface for repeatable agent work.,"Inspectable GitHub source (1,720 stars; 146 forks; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,759,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L759,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,builder,source-implementation,ok,https://github.com/ghuntley/how-to-ralph-wiggum,GitHub - ghuntley/how-to-ralph-wiggum: The Ralph Wiggum Techniqueβ€”the AI development methodology that reduces software costs to less than a fast food worker's wage. Β· GitHub,The Ralph Wiggum Techniqueβ€”the AI development methodology that reduces software costs to less than a fast food worker's wage. - ghuntley/how-to-ralph-wiggum,,2026-01-10,2026,ghuntley/how-to-ralph-wiggum,GitHub,,,,github-api,ghuntley/how-to-ralph-wiggum,1720,146,,2026-01-10T04:32:01Z,2026-07-17T13:23:53Z,,2026-07-17T17:58:18+00:00 @@ -222,7 +222,7 @@ ale-0220,Coding-Agent Loop Systems,coding-agent-loop-systems,Blog,πŸ“,Introduci ale-0221,Coding-Agent Loop Systems,coding-agent-loop-systems,Blog,πŸ“,Towards Self-Driving Codebases,https://cursor.com/blog/self-driving-codebases,external,cursor.com,"Cursor research on running thousands of coding agents as a recursive planner-subplanner-worker hierarchy sustaining roughly 1,000 commits per hour, finding that tolerating small error rates that peer agents later fix beats enforcing per-step correctness.","Cursor research on running thousands of coding agents as a recursive planner-subplanner-worker hierarchy sustaining roughly 1,000 commits per hour, finding that tolerating small error rates that peer agents later fix beats enforcing per-step correctness.","Cursor research on running thousands of coding agents as a recursive planner-subplanner-worker hierarchy sustaining roughly 1,000 commits per hour, finding that tolerating small error rates that peer agents later fix beats enforcing per-step correctness.","Uses real automated software-engineering systems as evidence for practical loop architectures. Cursor research on running thousands of coding agents as a recursive planner-subplanner-worker hierarchy sustaining roughly 1,000 commits per hour, finding that tolerating small error rates that peer agents later fix beats enforcing per-step correctness.",Use Towards Self-Driving Codebases to choose an implementation surface for repeatable agent work.,"Contextual source from cursor.com; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,804,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L804,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,builder,practitioner-analysis,ok,https://cursor.com/blog/self-driving-codebases,Towards self-driving codebases Β· Cursor,We're making a part of our multi-agent research harness available to try today in preview.,Wilson Lin,,,,Cursor,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0222,Coding-Agent Loop Systems,coding-agent-loop-systems,Blog,πŸ“,Factory: Incident Response Automation,https://factory.ai/news/incident-response,external,factory.ai,"Factory's July 10, 2026 launch where a Droid triggered by Slack alerts (Sentry, Datadog, Rootly, Axiom) autonomously investigates each incident on a dedicated computer, triages, prepares fixes, and reports back in the thread, recording what it learns in a persistent runbook that Factory says improves its incident response over time.","Factory's July 10, 2026 launch where a Droid triggered by Slack alerts (Sentry, Datadog, Rootly, Axiom) autonomously investigates each incident on a dedicated computer, triages, prepares fixes, and reports back in the thread, recording what it learns in a persistent runbook that Factory says improves its incident response over time.","Factory's July 10, 2026 launch where a Droid triggered by Slack alerts (Sentry, Datadog, Rootly, Axiom) autonomously investigates each incident on a dedicated computer, triages, prepares fixes, and reports back in the thread, recording what it learns in a persistent runbook that Factory says improves its incident response over time.","State persistence is explicit enough for repeated runs and handoff. Factory's July 10, 2026 launch where a Droid triggered by Slack alerts (Sentry, Datadog, Rootly, Axiom) autonomously investigates each incident on a dedicated computer, triages, prepares fixes, and reports back in the thread, recording what it learns in a persistent runbook that Factory says improves its incident response over time.",Use Factory: Incident Response Automation to choose an implementation surface for repeatable agent work.,"Contextual source from factory.ai; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,805,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L805,,Build,build,"Choose runtimes, tools, and delegation surfaces.",trigger;state,builder,practitioner-analysis,ok,https://factory.ai/news/incident-response,Incident Response | Factory.ai Factory.ai Logo Arrow Right Icon,"On-call alerts have always been stomach-dropping moments. Someone's dinner, weekend, or launch review gets hijacked for ...",Factory,2026-07-10,2026,,Factory,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0223,Coding-Agent Loop Systems,coding-agent-loop-systems,Blog,πŸ“,A Week-Long Autonomous Voxel Manhattan Build,https://x.com/mattshumer_/status/2075268746315268138,external,x.com,Matt Shumer's demonstration of a single-prompt run in which a frontier model worked autonomously for almost a week with subagent fan-out to build a navigable voxel Manhattan.,Matt Shumer's demonstration of a single-prompt run in which a frontier model worked autonomously for almost a week with subagent fan-out to build a navigable voxel Manhattan.,Matt Shumer's demonstration of a single-prompt run in which a frontier model worked autonomously for almost a week with subagent fan-out to build a navigable voxel Manhattan.,"The work separates roles across agents, verifiers, or orchestration layers. Matt Shumer's demonstration of a single-prompt run in which a frontier model worked autonomously for almost a week with subagent fan-out to build a navigable voxel Manhattan.",Use A Week-Long Autonomous Voxel Manhattan Build to choose an implementation surface for repeatable agent work.,"Contextual source from x.com; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,806,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L806,,Build,build,"Choose runtimes, tools, and delegation surfaces.",delegation,builder,practitioner-analysis,ok,https://x.com/mattshumer_/status/2075268746315268138,"Matt Shumer on X: ""GPT-5.6-Sol one-shotted this voxel-based Manhattan. Just look at the precision... it's insane. It ran for almost a week, completely autonomously, to get the job done. https://t.co/LZgthaBnqL"" / X","GPT-5.6-Sol one-shotted this voxel-based Manhattan. Just look at the precision... it's insane. It ran for almost a week, completely autonomously, to get the job done.",,2026-07-09,2026,,X (formerly Twitter),,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 -ale-0224,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,Self-Improving AI Coding Agents Through Accumulated Behavioral Rules: A Closed-Loop Framework,https://arxiv.org/abs/2607.13091,external,arxiv.org,"Converts accepted review feedback into versioned behavioral rules that future coding sessions can apply; across 11 reported production sessions, error classes covered by a rule did not recur, a promising but deliberately small-scope result.","Converts accepted review feedback into versioned behavioral rules that future coding sessions can apply; across 11 reported production sessions, error classes covered by a rule did not recur, a promising but deliberately small-scope result.","Converts accepted review feedback into versioned behavioral rules that future coding sessions can apply; across 11 reported production sessions, error classes covered by a rule did not recur, a promising but deliberately small-scope result.","Uses real automated software-engineering systems as evidence for practical loop architectures. Converts accepted review feedback into versioned behavioral rules that future coding sessions can apply; across 11 reported production sessions, error classes covered by a rule did not recur, a promising but deliberately small-scope result.",Use Self-Improving AI Coding Agents Through Accumulated Behavioral Rules: A Closed-Loop Framework to choose an implementation surface for repeatable agent work.,Research source arXiv:2607.13091; inspect its method and evaluation before treating results as production evidence.,medium,README.md,807,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L807,2026-07-17,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.13091,[2607.13091] Self-Improving AI Coding Agents Through Accumulated Behavioral Rules: A Closed-Loop Framework,"LLM-based coding agents repeat the same classes of mistakes across sessions because they lack a mechanism to retain corrections from human review feedback. We present a closed-loop framework in which every accepted review comment is codified as a persistent behavioral rule, progressively expanding the set of error classes the agent can self-detect. The framework combines an accumulating rule set in a version-controlled instruction file, a self-review checklist executed before code submission, and automated validation that ensures rule set integrity as it grows. In deployment across a 35+ service microservices platform, the rule set grew from 5 to 18 behavioral rules, 15+ language-specific standards, and a 15-item self-review checklist, all derived from real review feedback. We present empirical results from 11 recorded working sessions spanning code generation, PR review, incident investigation, and cross service refactoring. We observe that accumulated rules shift review effort from low-level correctness toward design-level validation, achieve a measured 0% recurrence rate for ruled-against error classes, and transfer across heterogeneous agent interfaces. We compare our approach against related work in experiential LLM learning (Reflexion, ExpeL, Voyager) and automated code review (CodeReviewer, SWE-bench agents), showing that our framework achieves persistent cross-session learning without weight updates, operates on production codebases rather than synthetic benchmarks, and addresses an orthogonal dimension (behavioral consistency over time) that existing benchmarks do not measure. The result is a coding agent that improves with every review cycle, accumulating the engineering wisdom of its human collaborators without changing a single model weight.",Aditya Aggarwal; Nahid Farhady Ghalaty,2026-07-13,2026,arXiv,arXiv,,Already presented and accepted in - 32nd ICE IEEE/ITMC Conference (ICE 2026),cs.SE,arxiv-api,,,,,,,2607.13091,2026-07-17T17:58:18+00:00 +ale-0224,Coding-Agent Loop Systems,coding-agent-loop-systems,Paper,πŸ“„,Self-Improving AI Coding Agents Through Accumulated Behavioral Rules: A Closed-Loop Framework,https://arxiv.org/abs/2607.13091,external,arxiv.org,"Converts accepted review feedback into versioned behavioral rules that future coding sessions can apply; across 11 reported production sessions, error classes covered by a rule did not recur, a promising but deliberately small-scope result.","Converts accepted review feedback into versioned behavioral rules that future coding sessions can apply; across 11 reported production sessions, error classes covered by a rule did not recur, a promising but deliberately small-scope result.","Converts accepted review feedback into versioned behavioral rules that future coding sessions can apply; across 11 reported production sessions, error classes covered by a rule did not recur, a promising but deliberately small-scope result.","Uses real automated software-engineering systems as evidence for practical loop architectures. Converts accepted review feedback into versioned behavioral rules that future coding sessions can apply; across 11 reported production sessions, error classes covered by a rule did not recur, a promising but deliberately small-scope result.",Use Self-Improving AI Coding Agents Through Accumulated Behavioral Rules: A Closed-Loop Framework to choose an implementation surface for repeatable agent work.,Research source arXiv:2607.13091; inspect its method and evaluation before treating results as production evidence.,medium,README.md,807,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L807,2026-07-17,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation;verification;state,researcher;evaluator,research-paper,ok,https://arxiv.org/abs/2607.13091,[2607.13091] Self-Improving AI Coding Agents Through Accumulated Behavioral Rules: A Closed-Loop Framework,"LLM-based coding agents repeat the same classes of mistakes across sessions because they lack a mechanism to retain corrections from human review feedback. We present a closed-loop framework in which every accepted review comment is codified as a persistent behavioral rule, progressively expanding the set of error classes the agent can self-detect. The framework combines an accumulating rule set in a version-controlled instruction file, a self-review checklist executed before code submission, and automated validation that ensures rule set integrity as it grows. In deployment across a 35+ service microservices platform, the rule set grew from 5 to 18 behavioral rules, 15+ language-specific standards, and a 15-item self-review checklist, all derived from real review feedback. We present empirical results from 11 recorded working sessions spanning code generation, PR review, incident investigation, and cross service refactoring. We observe that accumulated rules shift review effort from low-level correctness toward design-level validation, achieve a measured 0% recurrence rate for ruled-against error classes, and transfer across heterogeneous agent interfaces. We compare our approach against related work in experiential LLM learning (Reflexion, ExpeL, Voyager) and automated code review (CodeReviewer, SWE-bench agents), showing that our framework achieves persistent cross-session learning without weight updates, operates on production codebases rather than synthetic benchmarks, and addresses an orthogonal dimension (behavioral consistency over time) that existing benchmarks do not measure. The result is a coding agent that improves with every review cycle, accumulating the engineering wisdom of its human collaborators without changing a single model weight.",Aditya Aggarwal; Nahid Farhady Ghalaty,2026-06-22,2026,32nd IEEE International Conference on Engineering Technology and Innovation (ICE/ITMC),IEEE,,Accepted at 32nd IEEE International Conference on Engineering Technology and Innovation (ICE/ITMC); the linked arXiv record is the available paper version.,cs.SE,Current arXiv acceptance note and official conference page,,,,,,,2607.13091,2026-07-17T17:58:18+00:00 ale-0225,Verification And Feedback Gates,verification-and-feedback-gates,Blog,πŸ“,Why Agentic Systems Must Produce Deterministic Outputs to Scale,https://streamzero.com/blog/posts/deep-dives-tools-technologies-architectures/agentic-patterns/why-agentic-systems-must-produce-deterministic-outputs-to-scale,external,streamzero.com,"Argues for deterministic boundaries, contracts, and execution gates around probabilistic agent reasoning.","Argues for deterministic boundaries, contracts, and execution gates around probabilistic agent reasoning.","Argues for deterministic boundaries, contracts, and execution gates around probabilistic agent reasoning.","Treats feedback, telemetry, and deterministic artifacts as loop-control gates. Argues for deterministic boundaries, contracts, and execution gates around probabilistic agent reasoning.",Use Why Agentic Systems Must Produce Deterministic Outputs to Scale to measure progress and gate completion with repeatable evidence.,"Contextual source from streamzero.com; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,816,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L816,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,evaluator,practitioner-analysis,ok,https://streamzero.com/blog/posts/deep-dives-tools-technologies-architectures/agentic-patterns/why-agentic-systems-must-produce-deterministic-outputs-to-scale,Why Agentic Systems Must Produce Deterministic Outputs to Scale,"Agentic systems are gaining traction, but their inherent non-determinism poses a significant challenge for production environments. This document argues that deterministic outputs are essential for scaling agentic systems, enabling validation, security, and compliance in critical applications.",,,,,streamzero.com,,,,domain-fallback,,,,,,,,2026-07-17T17:58:18+00:00 ale-0226,Verification And Feedback Gates,verification-and-feedback-gates,Pattern,πŸ”,Stop Babysitting Your Coding Agent. Give It Backpressure.,https://generativeprogrammer.com/p/stop-babysitting-your-coding-agent,external,generativeprogrammer.com,"Explains how to turn tests, linters, builds, traces, and other signals into feedback loops for coding agents.","Explains how to turn tests, linters, builds, traces, and other signals into feedback loops for coding agents.","Explains how to turn tests, linters, builds, traces, and other signals into feedback loops for coding agents.","Treats feedback, telemetry, and deterministic artifacts as loop-control gates. Explains how to turn tests, linters, builds, traces, and other signals into feedback loops for coding agents.",Use Stop Babysitting Your Coding Agent. Give It Backpressure. to measure progress and gate completion with repeatable evidence.,Operational pattern or playbook; signal comes from reusable loop structure and practical transferability.,medium,README.md,817,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L817,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;exit,builder;evaluator,operational-pattern,ok,https://generativeprogrammer.com/p/stop-babysitting-your-coding-agent,Stop Babysitting Your Coding Agent. Give It Backpressure.,Backpressure is feedback that reaches the agent before the agent reaches the human.,Bilgin Ibryam,,,,generativeprogrammer.com,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0227,Verification And Feedback Gates,verification-and-feedback-gates,Pattern,πŸ”,How to Build a Self-Verification Loop in Claude Code,https://dev.to/shipwithaiio/how-to-build-a-self-verification-loop-in-claude-code-3-layers-20-minutes-m1p,external,dev.to,"Uses hooks to enforce syntax, intent, and regression checks before an agent can finish.","Uses hooks to enforce syntax, intent, and regression checks before an agent can finish.","Uses hooks to enforce syntax, intent, and regression checks before an agent can finish.","The agent workflow includes explicit self-checking or gated completion. Uses hooks to enforce syntax, intent, and regression checks before an agent can finish.",Use How to Build a Self-Verification Loop in Claude Code to measure progress and gate completion with repeatable evidence.,Operational pattern or playbook; signal comes from reusable loop structure and practical transferability.,medium,README.md,818,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L818,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,builder;evaluator,operational-pattern,ok,https://dev.to/shipwithaiio/how-to-build-a-self-verification-loop-in-claude-code-3-layers-20-minutes-m1p,"How to Build a Self-Verification Loop in Claude Code (3 Layers, 20 Minutes) - DEV Community Navigation menu Search Search Close More... Copy link Enter fullscreen mode Exit fullscreen mode Enter fullscreen mode Exit fullscreen mode Enter fullscreen mode Exit fullscreen mode Enter fullscreen mode Exit fullscreen mode Enter fullscreen mode Exit fullscreen mode Enter fullscreen mode Exit fullscreen mode","Claude Code's Stop hook blocks the agent from finishing until verification passes. Combine it with... Tagged with ai, programming, productivity, claude.",,,,,DEV Community,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 @@ -259,13 +259,13 @@ ale-0257,Verification And Feedback Gates,verification-and-feedback-gates,Tool, ale-0258,Verification And Feedback Gates,verification-and-feedback-gates,Tool,🧰,Mindwalk,https://github.com/cosmtrek/mindwalk,external,github.com,"Local visualization tool that replays Claude Code and Codex session logs as light moving across a 3D map of the repository, making long agent runs inspectable after the fact.","Local visualization tool that replays Claude Code and Codex session logs as light moving across a 3D map of the repository, making long agent runs inspectable after the fact.","Local visualization tool that replays Claude Code and Codex session logs as light moving across a 3D map of the repository, making long agent runs inspectable after the fact.","Treats feedback, telemetry, and deterministic artifacts as loop-control gates. Local visualization tool that replays Claude Code and Codex session logs as light moving across a 3D map of the repository, making long agent runs inspectable after the fact.",Use Mindwalk to measure progress and gate completion with repeatable evidence.,"Inspectable GitHub source (771 stars; 45 forks; MIT license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,857,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L857,,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace,builder;evaluator,source-implementation,ok,https://github.com/cosmtrek/mindwalk,GitHub - cosmtrek/mindwalk: A visualization tool that replays coding-agent sessions on a 3D map of your codebase. Β· GitHub,A visualization tool that replays coding-agent sessions on a 3D map of your codebase. - cosmtrek/mindwalk,,2026-07-09,2026,cosmtrek/mindwalk,GitHub,,,,github-api,cosmtrek/mindwalk,771,45,MIT,2026-07-09T11:41:46Z,2026-07-17T16:48:38Z,,2026-07-17T17:58:18+00:00 ale-0259,Verification And Feedback Gates,verification-and-feedback-gates,Tool,🧰,Waggle,https://github.com/modiqo/waggle,external,github.com,"MCP-native reference layer for agent handoffs: instead of pasting full context between agents, it passes a compact attributed, resolvable reference token that the receiving agent expands on demand.","MCP-native reference layer for agent handoffs: instead of pasting full context between agents, it passes a compact attributed, resolvable reference token that the receiving agent expands on demand.","MCP-native reference layer for agent handoffs: instead of pasting full context between agents, it passes a compact attributed, resolvable reference token that the receiving agent expands on demand.","Context is managed as durable loop state rather than a single prompt payload. MCP-native reference layer for agent handoffs: instead of pasting full context between agents, it passes a compact attributed, resolvable reference token that the receiving agent expands on demand.",Use Waggle to measure progress and gate completion with repeatable evidence.,"Inspectable GitHub source (808 stars; 141 forks; Apache-2.0 license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,858,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L858,2026-07-15,Verify,verify,"Gate progress with tests, evals, and evidence.",context;delegation;budget,builder;evaluator,source-implementation,ok,https://github.com/modiqo/waggle,"GitHub - modiqo/waggle: Attributed, resolvable artifact references for agent handoffs β€” a ~30-byte token instead of pasted context. MCP-native; the reference layer for the agent-harness world. Β· GitHub","Attributed, resolvable artifact references for agent handoffs β€” a ~30-byte token instead of pasted context. MCP-native; the reference layer for the agent-harness world. - modiqo/waggle",,2026-07-08,2026,modiqo/waggle,GitHub,,,,github-api,modiqo/waggle,808,141,Apache-2.0,2026-07-08T04:33:09Z,2026-07-17T17:45:53Z,,2026-07-17T17:58:18+00:00 ale-0260,Verification And Feedback Gates,verification-and-feedback-gates,Tool,🧰,Jacquard,https://github.com/jbwinters/jacquard-lang,external,github.com,"Research language designed around the machine-writes, human-verifies contract, using effect-typed signatures so an agent's generated code carries checkable declarations of what it is allowed to touch.","Research language designed around the machine-writes, human-verifies contract, using effect-typed signatures so an agent's generated code carries checkable declarations of what it is allowed to touch.","Research language designed around the machine-writes, human-verifies contract, using effect-typed signatures so an agent's generated code carries checkable declarations of what it is allowed to touch.","Treats feedback, telemetry, and deterministic artifacts as loop-control gates. Research language designed around the machine-writes, human-verifies contract, using effect-typed signatures so an agent's generated code carries checkable declarations of what it is allowed to touch.",Use Jacquard to measure progress and gate completion with repeatable evidence.,"Inspectable GitHub source (93 stars; 2 forks; Apache-2.0 license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,859,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L859,2026-07-15,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;escalation,builder;evaluator,source-implementation,ok,https://github.com/jbwinters/jacquard-lang,GitHub - jbwinters/jacquard-lang: Jacquard is a small programming language designed for a regime in which most code is written by machine-learning models and reviewed by people. Β· GitHub,Jacquard is a small programming language designed for a regime in which most code is written by machine-learning models and reviewed by people. - jbwinters/jacquard-lang,,2026-07-06,2026,jbwinters/jacquard-lang,GitHub,,,,github-api,jbwinters/jacquard-lang,93,2,Apache-2.0,2026-07-06T23:14:47Z,2026-07-17T13:30:59Z,,2026-07-17T17:58:18+00:00 -ale-0261,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Agentic Verification of Software Systems,https://arxiv.org/abs/2511.17330,external,arxiv.org,"Pairs a coding agent with a theorem prover (AutoRocq) in a generate-and-validate loop, turning formal proof into the exit gate for trusted automatic programming.","Pairs a coding agent with a theorem prover (AutoRocq) in a generate-and-validate loop, turning formal proof into the exit gate for trusted automatic programming.","Pairs a coding agent with a theorem prover (AutoRocq) in a generate-and-validate loop, turning formal proof into the exit gate for trusted automatic programming.","Verification is promoted from a final check to a loop-control signal. Pairs a coding agent with a theorem prover (AutoRocq) in a generate-and-validate loop, turning formal proof into the exit gate for trusted automatic programming.",Use Agentic Verification of Software Systems to measure progress and gate completion with repeatable evidence.,Research source arXiv:2511.17330; inspect its method and evaluation before treating results as production evidence.,medium,README.md,864,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L864,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;exit,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2511.17330,[2511.17330] Agentic Verification of Software Systems,"Automatically generated code is gaining traction recently, owing to the prevalence of Large Language Models (LLMs). Further, the AlphaProof initiative has demonstrated the possibility of using AI for general mathematical reasoning. Reasoning about computer programs (software) can be accomplished via general mathematical reasoning; however, it tends to be more structured and richer in contexts. This forms an attractive proposition, since then AI agents can be used to reason about voluminous code that gets generated by AI. In this work, we present a first LLM agent, AutoRocq, for conducting program verification. Unlike past works, which rely on extensive training of LLMs on proof examples, our agent learns on-the-fly and improves the proof via an iterative refinement loop. The iterative improvement of the proof is achieved by the proof agent communicating with the Rocq (formerly Coq) theorem prover to get additional context and feedback. The final result of the iteration is a proof derivation checked by the Rocq theorem prover. In this way, our proof construction involves autonomous collaboration between the proof agent and the theorem prover. This autonomy facilitates the search for proofs and decision-making in deciding on the structure of the proof tree. Experimental evaluation on SV-COMP benchmarks and on Linux kernel modules shows promising efficacy in achieving automated program verification. As automation in code generation becomes more widespread, we posit that our proof agent can be potentially integrated with AI coding agents to achieve a generate and validate loop, thus moving closer to the vision of trusted automatic programming.",Haoxin Tu; Huan Zhao; Yahui Song; Mehtab Zafar; Ruijie Meng; Abhik Roychoudhury,2025-11-21,2025,arXiv,arXiv,10.1145/3808164,Camera-ready version appeared in the Proceedings of the ACM International Conference on the Foundations of Software Engineering (FSE 2026),cs.SE,arxiv-api,,,,,,,2511.17330,2026-07-17T17:58:18+00:00 -ale-0262,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,"A Trace-Based Assurance Framework for Agentic AI Orchestration: Contracts, Testing, and Governance",https://arxiv.org/abs/2603.18096,external,arxiv.org,"Treats execution traces as the assurance substrate, pairing machine-checkable contracts, testing, and governance so recurring agent orchestration stays verifiable and auditable.","Treats execution traces as the assurance substrate, pairing machine-checkable contracts, testing, and governance so recurring agent orchestration stays verifiable and auditable.","Treats execution traces as the assurance substrate, pairing machine-checkable contracts, testing, and governance so recurring agent orchestration stays verifiable and auditable.","Orchestration and control flow are made explicit and inspectable. Treats execution traces as the assurance substrate, pairing machine-checkable contracts, testing, and governance so recurring agent orchestration stays verifiable and auditable.","Use A Trace-Based Assurance Framework for Agentic AI Orchestration: Contracts, Testing, and Governance to measure progress and gate completion with repeatable evidence.",Research source arXiv:2603.18096; inspect its method and evaluation before treating results as production evidence.,medium,README.md,865,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L865,,Verify,verify,"Gate progress with tests, evals, and evidence.",delegation;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2603.18096,"[2603.18096] A Trace-Based Assurance Framework for Agentic AI Orchestration: Contracts, Testing, and Governance","In Agentic AI, Large Language Models (LLMs) are increasingly used in the orchestration layer to coordinate multiple agents and to interact with external services, retrieval components, and shared memory. In this setting, failures are not limited to incorrect final outputs. They also arise from long-horizon interaction, stochastic decisions, and external side effects (such as API calls, database writes, and message sends). Common failures include non-termination, role drift, propagation of unsupported claims, and attacks via untrusted context or external channels. This paper presents an assurance framework for such Agentic AI systems. Executions are instrumented as Message-Action Traces (MAT) with explicit step and trace contracts. Contracts provide machine-checkable verdicts, localize the first violating step, and support deterministic replay. The framework includes stress testing, formulated as a budgeted counterexample search over bounded perturbations. It also supports structured fault injection at service, retrieval, and memory boundaries to assess containment under realistic operational faults and degraded conditions. Finally, governance is treated as a runtime component, enforcing per-agent capability limits and action mediation (allow, rewrite, block) at the language-to-action boundary. To support comparative evaluations across stochastic seeds, models, and orchestration configurations, the paper defines trace-based metrics for task success, termination reliability, contract compliance, factuality indicators, containment rate, and governance outcome distributions. More broadly, the framework is intended as a common abstraction to support testing and evaluation of multi-agent LLM systems, and to facilitate reproducible comparison across orchestration designs and configurations.",Ciprian Paduraru; Petru-Liviu Bouruc; Alin Stefanescu,2026-03-18,2026,arXiv,arXiv,,,cs.MA,arxiv-api,,,,,,,2603.18096,2026-07-17T17:58:18+00:00 +ale-0261,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Agentic Verification of Software Systems,https://arxiv.org/abs/2511.17330,external,arxiv.org,"Pairs a coding agent with a theorem prover (AutoRocq) in a generate-and-validate loop, turning formal proof into the exit gate for trusted automatic programming.","Pairs a coding agent with a theorem prover (AutoRocq) in a generate-and-validate loop, turning formal proof into the exit gate for trusted automatic programming.","Pairs a coding agent with a theorem prover (AutoRocq) in a generate-and-validate loop, turning formal proof into the exit gate for trusted automatic programming.","Verification is promoted from a final check to a loop-control signal. Pairs a coding agent with a theorem prover (AutoRocq) in a generate-and-validate loop, turning formal proof into the exit gate for trusted automatic programming.",Use Agentic Verification of Software Systems to measure progress and gate completion with repeatable evidence.,Research source arXiv:2511.17330; inspect its method and evaluation before treating results as production evidence.,medium,README.md,864,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L864,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;exit,researcher;evaluator,research-paper,ok,https://doi.org/10.1145/3808164,[2511.17330] Agentic Verification of Software Systems,"Automatically generated code is gaining traction recently, owing to the prevalence of Large Language Models (LLMs). Further, the AlphaProof initiative has demonstrated the possibility of using AI for general mathematical reasoning. Reasoning about computer programs (software) can be accomplished via general mathematical reasoning; however, it tends to be more structured and richer in contexts. This forms an attractive proposition, since then AI agents can be used to reason about voluminous code that gets generated by AI. In this work, we present a first LLM agent, AutoRocq, for conducting program verification. Unlike past works, which rely on extensive training of LLMs on proof examples, our agent learns on-the-fly and improves the proof via an iterative refinement loop. The iterative improvement of the proof is achieved by the proof agent communicating with the Rocq (formerly Coq) theorem prover to get additional context and feedback. The final result of the iteration is a proof derivation checked by the Rocq theorem prover. In this way, our proof construction involves autonomous collaboration between the proof agent and the theorem prover. This autonomy facilitates the search for proofs and decision-making in deciding on the structure of the proof tree. Experimental evaluation on SV-COMP benchmarks and on Linux kernel modules shows promising efficacy in achieving automated program verification. As automation in code generation becomes more widespread, we posit that our proof agent can be potentially integrated with AI coding agents to achieve a generate and validate loop, thus moving closer to the vision of trusted automatic programming.",Haoxin Tu; Huan Zhao; Yahui Song; Mehtab Zafar; Ruijie Meng; Abhik Roychoudhury,2026-06-30,2026,Proceedings of the ACM on Software Engineering 3 (FSE),Association for Computing Machinery,10.1145/3808164,Published in Proceedings of the ACM on Software Engineering 3 (FSE); the linked arXiv record remains available for open access.,cs.SE,ACM DOI record,,,,,,,2511.17330,2026-07-17T17:58:18+00:00 +ale-0262,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,"A Trace-Based Assurance Framework for Agentic AI Orchestration: Contracts, Testing, and Governance",https://arxiv.org/abs/2603.18096,external,arxiv.org,"Treats execution traces as the assurance substrate, pairing machine-checkable contracts, testing, and governance so recurring agent orchestration stays verifiable and auditable.","Treats execution traces as the assurance substrate, pairing machine-checkable contracts, testing, and governance so recurring agent orchestration stays verifiable and auditable.","Treats execution traces as the assurance substrate, pairing machine-checkable contracts, testing, and governance so recurring agent orchestration stays verifiable and auditable.","Orchestration and control flow are made explicit and inspectable. Treats execution traces as the assurance substrate, pairing machine-checkable contracts, testing, and governance so recurring agent orchestration stays verifiable and auditable.","Use A Trace-Based Assurance Framework for Agentic AI Orchestration: Contracts, Testing, and Governance to measure progress and gate completion with repeatable evidence.",Research source arXiv:2603.18096; inspect its method and evaluation before treating results as production evidence.,medium,README.md,865,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L865,,Verify,verify,"Gate progress with tests, evals, and evidence.",delegation;verification,researcher;evaluator,research-paper,ok,https://doi.org/10.5220/0014840300004015,"[2603.18096] A Trace-Based Assurance Framework for Agentic AI Orchestration: Contracts, Testing, and Governance","In Agentic AI, Large Language Models (LLMs) are increasingly used in the orchestration layer to coordinate multiple agents and to interact with external services, retrieval components, and shared memory. In this setting, failures are not limited to incorrect final outputs. They also arise from long-horizon interaction, stochastic decisions, and external side effects (such as API calls, database writes, and message sends). Common failures include non-termination, role drift, propagation of unsupported claims, and attacks via untrusted context or external channels. This paper presents an assurance framework for such Agentic AI systems. Executions are instrumented as Message-Action Traces (MAT) with explicit step and trace contracts. Contracts provide machine-checkable verdicts, localize the first violating step, and support deterministic replay. The framework includes stress testing, formulated as a budgeted counterexample search over bounded perturbations. It also supports structured fault injection at service, retrieval, and memory boundaries to assess containment under realistic operational faults and degraded conditions. Finally, governance is treated as a runtime component, enforcing per-agent capability limits and action mediation (allow, rewrite, block) at the language-to-action boundary. To support comparative evaluations across stochastic seeds, models, and orchestration configurations, the paper defines trace-based metrics for task success, termination reliability, contract compliance, factuality indicators, containment rate, and governance outcome distributions. More broadly, the framework is intended as a common abstraction to support testing and evaluation of multi-agent LLM systems, and to facilitate reproducible comparison across orchestration designs and configurations.",Ciprian Paduraru; Petru-Liviu Bouruc; Alin Stefanescu,2026,2026,Proceedings of the 21st International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE),SCITEPRESS,10.5220/0014840300004015,Published in Proceedings of the 21st International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE); the linked arXiv record remains available for open access.,cs.MA,SCITEPRESS DOI record,,,,,,,2603.18096,2026-07-17T17:58:18+00:00 ale-0263,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Self-Evolving Agents with Anytime-Valid Certificates,https://arxiv.org/abs/2607.00871,external,arxiv.org,"Confines self-modification to a small steering adapter around a frozen base model and gates each change with anytime-valid statistical tests that emit auditable certificates, reporting solve-count gains and logged regression prevention on a SWE-bench Verified subset.","Confines self-modification to a small steering adapter around a frozen base model and gates each change with anytime-valid statistical tests that emit auditable certificates, reporting solve-count gains and logged regression prevention on a SWE-bench Verified subset.","Confines self-modification to a small steering adapter around a frozen base model and gates each change with anytime-valid statistical tests that emit auditable certificates, reporting solve-count gains and logged regression prevention on a SWE-bench Verified subset.","Verification is promoted from a final check to a loop-control signal. Confines self-modification to a small steering adapter around a frozen base model and gates each change with anytime-valid statistical tests that emit auditable certificates, reporting solve-count gains and logged regression prevention on a SWE-bench Verified subset.",Use Self-Evolving Agents with Anytime-Valid Certificates to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.00871; inspect its method and evaluation before treating results as production evidence.,medium,README.md,866,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L866,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.00871,[2607.00871] Self-Evolving Agents with Anytime-Valid Certificates,"Self-evolving agents violate the assumption behind most learning-theoretic guarantees: the data, evaluator, components, and hypothesis space are produced by the policy being updated. We present \textbf{SEA}, an architecture that confines self-modification to a small steering adapter and a versioned harness around a \emph{frozen} base model and admits each modification only through an anytime-valid gate that emits an auditable certificate against a fixed error budget. Five loop controllers compose published guarantees; because such gates can only \emph{select} among behaviors the frozen base already produces, five verifier-in-the-loop mechanisms -- best-of-$N$, micro-step search, self-authored reproduction oracles, search-layer control, and self-repair -- supply the dense, grader-free signal the gates require, computed from the issue text alone. On a $52$-instance SWE-bench Verified subset across four base models, base capability is the dominant, confound-free effect, and on two strong base models a deliberate no-op-composite control isolates the suite's contribution at $+4$ and $+5$ (\textsc{Glm}~5.2 $24\to28$; \textsc{Gpt} $29\to34$, the $65\%$ best), with event logs confirming that its mechanisms fire and prevent regressions. Results are single-run on expensive evaluations; confirming run-to-run variance and adapting the per-task algorithm mix are future work.",Biswa Sengupta,2026-07-01,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2607.00871,2026-07-17T17:58:18+00:00 ale-0264,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Delayed Verification Destabilizes Multi-Agent LLM Belief,https://arxiv.org/abs/2606.27409,external,arxiv.org,"Models verifier-corrector loops in multi-agent LLM systems as delayed consensus, deriving a stability threshold where verification that is too strong or too late turns factual consensus into oscillation, plus a greedy corrector-placement algorithm validated on five open models.","Models verifier-corrector loops in multi-agent LLM systems as delayed consensus, deriving a stability threshold where verification that is too strong or too late turns factual consensus into oscillation, plus a greedy corrector-placement algorithm validated on five open models.","Models verifier-corrector loops in multi-agent LLM systems as delayed consensus, deriving a stability threshold where verification that is too strong or too late turns factual consensus into oscillation, plus a greedy corrector-placement algorithm validated on five open models.","Verification is promoted from a final check to a loop-control signal. Models verifier-corrector loops in multi-agent LLM systems as delayed consensus, deriving a stability threshold where verification that is too strong or too late turns factual consensus into oscillation, plus a greedy corrector-placement algorithm validated on five open models.",Use Delayed Verification Destabilizes Multi-Agent LLM Belief to measure progress and gate completion with repeatable evidence.,Research source arXiv:2606.27409; inspect its method and evaluation before treating results as production evidence.,medium,README.md,867,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L867,,Verify,verify,"Gate progress with tests, evals, and evidence.",delegation;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2606.27409,[2606.27409] Delayed Verification Destabilizes Multi-Agent LLM Belief: Instability Thresholds and Optimal Corrector Placement,"Multi-agent large language model (LLM) systems often rely on verifier and critic agents to suppress hallucinations, but verification is delayed. During this delay, false claims can propagate through the agent network. We model this process as delayed consensus on a graph with grounded corrector nodes. Spectral decomposition by the grounded Laplacian yields a closed-form stability threshold for the verification dose: correction that is too strong or too delayed can turn consensus into oscillation. The most unstable regime occurs when the communication and verification delays coincide; for delay two, the threshold is the inverse golden ratio. The same framework gives a supermodular placement objective and a greedy (1-1/e)-approximation rule for assigning a limited corrector budget to influential nodes. Experiments across five open models confirm the predicted dose-delay oscillations. By contrast, grounded factual answering makes truth an absorbing boundary and eliminates the effect, suggesting that the instability is specific to signed-belief tasks while grounded verification remains stabilizing",Igor Itkin,2026-06-25,2026,arXiv,arXiv,,"20 pages, 5 figures, 1 table. Code and data: https://github.com/YehudaItkin/delayed-verification-llm",cs.MA,arxiv-api,,,,,,,2606.27409,2026-07-17T17:58:18+00:00 ale-0265,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Lean4Agent: Formal Modeling and Verification for Agent Workflow and Trajectory,https://arxiv.org/abs/2606.06523,external,arxiv.org,"Models agent workflows and trajectories in Lean 4 dependent types so semantic consistency is machine-checked rather than judged by an LLM, with verification-passing workflows outperforming failing ones by an average of 11.94% on software-engineering benchmarks.","Models agent workflows and trajectories in Lean 4 dependent types so semantic consistency is machine-checked rather than judged by an LLM, with verification-passing workflows outperforming failing ones by an average of 11.94% on software-engineering benchmarks.","Models agent workflows and trajectories in Lean 4 dependent types so semantic consistency is machine-checked rather than judged by an LLM, with verification-passing workflows outperforming failing ones by an average of 11.94% on software-engineering benchmarks.","Verification is promoted from a final check to a loop-control signal. Models agent workflows and trajectories in Lean 4 dependent types so semantic consistency is machine-checked rather than judged by an LLM, with verification-passing workflows outperforming failing ones by an average of 11.94% on software-engineering benchmarks.",Use Lean4Agent: Formal Modeling and Verification for Agent Workflow and Trajectory to measure progress and gate completion with repeatable evidence.,Research source arXiv:2606.06523; inspect its method and evaluation before treating results as production evidence.,medium,README.md,868,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L868,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2606.06523,[2606.06523] Lean4Agent: Formal Modeling and Verification for Agent Workflow and Trajectory,"Equipping Large Language Models (LLMs) to execute reliable multi-step workflows has become a central challenge in artificial intelligence. Despite recent advances in LLMs' agentic capabilities, most agent systems still lack formal methods for specifying, verifying, and debugging their workflow and execution trajectories. This challenge mirrors a long-standing problem in mathematics, where the ambiguity of natural languages (NLs) motivates the development of formal languages (FLs). Inspired by this paradigm, we propose **Lean4Agent**, to the best of our knowledge, the first framework that uses Lean4, a dependent-type FL to model and verify agent behavior. **Lean4Agent** launches **FormalAgentLib**, an extensible Lean4 library for formally modeling and verifying agent workflows' semantic consistency under explicit assumptions, and enabling localization of execution-time failures revealed by trajectories. Building on **FormalAgentLib**, we further develop **LeanEvolve**, which applies results in **FormalAgentLib** to revise workflows to enhance its capability. Extensive experiments on a hard problem subset of SWE-Bench-Verified and a subset of ELAIP-Bench across 5 leading LLMs indicate that the verification-passing workflows outperform the failing ones by an average of **11.94%**, and **LeanEvolve** further improves SWE performance by **7.47%** on average. Furthermore, **Lean4Agent** establishes a foundation for a new field of using expressive dependent-type FL to formally model and verify agent behavior.",Ruida Wang; Jerry Huang; Pengcheng Wang; Xuanqing Liu; Luyang Kong; Tong Zhang,2026-06-02,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2606.06523,2026-07-17T17:58:18+00:00 ale-0266,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,"Regimes: An Auditable, Held-Out-Gated Improvement Loop",https://arxiv.org/abs/2606.10241,external,arxiv.org,"Event-sourced agent runtime whose self-improvement loop gates every proposed repair behind static checks, sandbox execution, and held-out evaluation before adoption, keeping the full decision trail replayable.","Event-sourced agent runtime whose self-improvement loop gates every proposed repair behind static checks, sandbox execution, and held-out evaluation before adoption, keeping the full decision trail replayable.","Event-sourced agent runtime whose self-improvement loop gates every proposed repair behind static checks, sandbox execution, and held-out evaluation before adoption, keeping the full decision trail replayable.","Evaluation data is used as the feedback signal for improving loop behavior. Event-sourced agent runtime whose self-improvement loop gates every proposed repair behind static checks, sandbox execution, and held-out evaluation before adoption, keeping the full decision trail replayable.","Use Regimes: An Auditable, Held-Out-Gated Improvement Loop to measure progress and gate completion with repeatable evidence.",Research source arXiv:2606.10241; inspect its method and evaluation before treating results as production evidence.,medium,README.md,869,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L869,,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2606.10241,"[2606.10241] Regimes: An Auditable, Held-Out-Gated Improvement Loop Demonstrated on LongMemEval with ActiveGraph","Autonomous improvement loops are hard to trust because the improvement process is usually external scaffolding bolted onto the agent: failures go unlogged, diagnoses cannot be replayed, and promote-or-discard decisions land in a side database rather than the agent's own history. We show that an event-sourced agent runtime removes that friction and turns controlled improvement into a first-class workflow. When the agent's state is a deterministic projection of an append-only event log, failures are recorded, a run replays exactly from its log, candidate patches scope to typed pipeline seams, gates are auditable, and every promotion or discard is itself an event. We demonstrate this with Regimes, a loop on the ActiveGraph runtime that diagnoses failed evaluations, proposes a repair at a pipeline point, and promotes it only after static checks, sandbox execution, in-sample evaluation, and held-out validation. The loop is target-agnostic: the same control flow runs against different tasks through a common interface. On LongMemEval-S the dominant failure is not retrieval but reconciliation: the evidence is already in the assembled context, yet the reader answers incorrectly. Across five seeded held-out splits, Regimes discovers reader-prompt repairs that improve final held-out accuracy by +0.05 to +0.10 in four splits and +0.01 in one over-promotion split; two splits are individually significant (seed 5 unadjusted for its sequential promotion structure), and the pooled count is descriptive only, since the splits share one 500-question pool. The durable contributions are ActiveGraph as an auditable substrate that makes controlled improvement loops tractable, the held-out-gated loop it supports, the failure-regime taxonomy routing each failure to a pipeline location (whose marginal value over an unrouted baseline is the primary open question), and the prompt-as-discovery-probe hypothesis.",Yohei Nakajima,2026-06-08,2026,arXiv,arXiv,,"30 pages, 5 figures. Code and committed runs: https://github.com/yoheinakajima/regimes",cs.AI,arxiv-api,,,,,,,2606.10241,2026-07-17T17:58:18+00:00 -ale-0267,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Agentic CLEAR: Automating Multi-Level Evaluation of LLM Agents,https://arxiv.org/abs/2605.22608,external,arxiv.org,"Automated evaluation framework from IBM Research that grades agent behavior at system, trace, and node granularity without predefined error taxonomies, producing feedback aligned with human-annotated errors and predictive of task success.","Automated evaluation framework from IBM Research that grades agent behavior at system, trace, and node granularity without predefined error taxonomies, producing feedback aligned with human-annotated errors and predictive of task success.","Automated evaluation framework from IBM Research that grades agent behavior at system, trace, and node granularity without predefined error taxonomies, producing feedback aligned with human-annotated errors and predictive of task success.","Evaluation data is used as the feedback signal for improving loop behavior. Automated evaluation framework from IBM Research that grades agent behavior at system, trace, and node granularity without predefined error taxonomies, producing feedback aligned with human-annotated errors and predictive of task success.",Use Agentic CLEAR: Automating Multi-Level Evaluation of LLM Agents to measure progress and gate completion with repeatable evidence.,Research source arXiv:2605.22608; inspect its method and evaluation before treating results as production evidence.,medium,README.md,870,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L870,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;escalation,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2605.22608,[2605.22608] Agentic CLEAR: Automating Multi-Level Evaluation of LLM Agents,"Agentic systems are becoming more capable: agents define strategies, take actions, and interact with different environments. This autonomy poses serious challenges for overseeing and assessing agent behavior. Most current tools are limited, focusing on observability with basic evaluation capabilities or imposing static, hand-crafted error taxonomies that cannot adapt to new domains. To address this gap, we present Agentic CLEAR, an automatic, dynamic, and easy-to-use evaluation framework. It produces textual insights into the agent behavior on three levels of granularity: system, trace, and node. Agentic CLEAR operates above the observability layer, enabling seamless integration and featuring an intuitive UI that makes agent evaluation highly accessible. In our experiments on four benchmarks, seven agentic settings, and tens of thousands of LLM calls, we show that Agentic CLEAR produces high-quality, data-driven, insightful feedback. Our analysis shows strong alignment with human-annotated errors and the ability to predict task success rate.",Asaf Yehudai; Lilach Eden; Michal Shmueli-Scheuer,2026-05-21,2026,arXiv,arXiv,,ACL,cs.CL,arxiv-api,,,,,,,2605.22608,2026-07-17T17:58:18+00:00 +ale-0267,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Agentic CLEAR: Automating Multi-Level Evaluation of LLM Agents,https://arxiv.org/abs/2605.22608,external,arxiv.org,"Automated evaluation framework from IBM Research that grades agent behavior at system, trace, and node granularity without predefined error taxonomies, producing feedback aligned with human-annotated errors and predictive of task success.","Automated evaluation framework from IBM Research that grades agent behavior at system, trace, and node granularity without predefined error taxonomies, producing feedback aligned with human-annotated errors and predictive of task success.","Automated evaluation framework from IBM Research that grades agent behavior at system, trace, and node granularity without predefined error taxonomies, producing feedback aligned with human-annotated errors and predictive of task success.","Evaluation data is used as the feedback signal for improving loop behavior. Automated evaluation framework from IBM Research that grades agent behavior at system, trace, and node granularity without predefined error taxonomies, producing feedback aligned with human-annotated errors and predictive of task success.",Use Agentic CLEAR: Automating Multi-Level Evaluation of LLM Agents to measure progress and gate completion with repeatable evidence.,Research source arXiv:2605.22608; inspect its method and evaluation before treating results as production evidence.,medium,README.md,870,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L870,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;escalation,researcher;evaluator,research-paper,ok,https://aclanthology.org/2026.acl-demo.74/,[2605.22608] Agentic CLEAR: Automating Multi-Level Evaluation of LLM Agents,"Agentic systems are becoming more capable: agents define strategies, take actions, and interact with different environments. This autonomy poses serious challenges for overseeing and assessing agent behavior. Most current tools are limited, focusing on observability with basic evaluation capabilities or imposing static, hand-crafted error taxonomies that cannot adapt to new domains. To address this gap, we present Agentic CLEAR, an automatic, dynamic, and easy-to-use evaluation framework. It produces textual insights into the agent behavior on three levels of granularity: system, trace, and node. Agentic CLEAR operates above the observability layer, enabling seamless integration and featuring an intuitive UI that makes agent evaluation highly accessible. In our experiments on four benchmarks, seven agentic settings, and tens of thousands of LLM calls, we show that Agentic CLEAR produces high-quality, data-driven, insightful feedback. Our analysis shows strong alignment with human-annotated errors and the ability to predict task success rate.",Asaf Yehudai; Lilach Eden; Michal Shmueli-Scheuer,2026,2026,Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics: System Demonstrations (ACL),Association for Computational Linguistics,10.18653/v1/2026.acl-demo.74,Published in Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics: System Demonstrations (ACL); the linked arXiv record remains available for open access.,cs.CL,ACL Anthology and DOI records,,,,,,,2605.22608,2026-07-17T17:58:18+00:00 ale-0268,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Diagnosis-Driven Automatic Repair for Agentic Workflow via Symbolic Inference,https://arxiv.org/abs/2607.02882,external,arxiv.org,"FlowFixer converts runs of platform-built agentic workflows (Dify, Coze, n8n) into symbolic traces, infers correctness specs and node dependencies to localize root-cause failures, and generates targeted repairs at a 71.3% success rate.","FlowFixer converts runs of platform-built agentic workflows (Dify, Coze, n8n) into symbolic traces, infers correctness specs and node dependencies to localize root-cause failures, and generates targeted repairs at a 71.3% success rate.","FlowFixer converts runs of platform-built agentic workflows (Dify, Coze, n8n) into symbolic traces, infers correctness specs and node dependencies to localize root-cause failures, and generates targeted repairs at a 71.3% success rate.","Treats feedback, telemetry, and deterministic artifacts as loop-control gates. FlowFixer converts runs of platform-built agentic workflows (Dify, Coze, n8n) into symbolic traces, infers correctness specs and node dependencies to localize root-cause failures, and generates targeted repairs at a 71.3% success rate.",Use Diagnosis-Driven Automatic Repair for Agentic Workflow via Symbolic Inference to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.02882; inspect its method and evaluation before treating results as production evidence.,medium,README.md,871,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L871,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.02882,[2607.02882] Diagnosis-Driven Automatic Repair for Agentic Workflow via Symbolic Inference,"Platform-orchestrated agentic workflows have become a popular paradigm for developing LLM-based applications. However, their reliability remains a major challenge due to the uncertainty of LLM outputs, complex inter-node dependencies, and heterogeneous tool interactions. Existing agentic workflow optimization and agent enhancement methods primarily rely on trajectory-level feedback. Without explicitly identifying the underlying failure root causes, their resulting repair plans are often insufficiently targeted. We propose FlowFixer, a diagnosis-driven automated repair framework for agentic workflows. FlowFixer first transforms workflow executions into unified symbolic traces and performs symbolic inference to derive executable behavioral specifications that capture node correctness, temporal dependencies, and causal relationships. Based on specification verification, it conducts failure attribution and root cause analysis, and then generates targeted repair patches. To reduce verification costs, FlowFixer further employs a multi-dimensional pre-execution assessment to filter infeasible repairs before dynamic verification. We evaluate FlowFixer on workflow failures collected from three popular development platforms: Dify, Coze and n8n. Results show that FlowFixer achieves a repair success rate of 71.3%, outperforming state-of-the-art baselines by 11.9% to 27.6%. It also improves failure attribution accuracy by 4.8% to 33.1% and root cause analysis accuracy by 15.3% to 38.8%. This work offers a new perspective on reliable diagnosis and repair of agentic workflows through symbolic modeling and inference.",Xuyan Ma; Yawen Wang; Junjie Wang; Xiaofei Xie; Boyu Wu; Mingyang Li; Dandan Wang; Qing Wang,2026-07-03,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.02882,2026-07-17T17:58:18+00:00 ale-0269,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,SkillCoach: Self-Evolving Rubrics for Evaluating and Enhancing Agentic Skill-Use,https://arxiv.org/abs/2607.01874,external,arxiv.org,"Self-evolving rubric framework that scores agent trajectories on skill selection, following, composition, and reflection, exposing failures that pass/fail outcome checks miss and beating outcome-only filtering as a training signal.","Self-evolving rubric framework that scores agent trajectories on skill selection, following, composition, and reflection, exposing failures that pass/fail outcome checks miss and beating outcome-only filtering as a training signal.","Self-evolving rubric framework that scores agent trajectories on skill selection, following, composition, and reflection, exposing failures that pass/fail outcome checks miss and beating outcome-only filtering as a training signal.","Treats feedback, telemetry, and deterministic artifacts as loop-control gates. Self-evolving rubric framework that scores agent trajectories on skill selection, following, composition, and reflection, exposing failures that pass/fail outcome checks miss and beating outcome-only filtering as a training signal.",Use SkillCoach: Self-Evolving Rubrics for Evaluating and Enhancing Agentic Skill-Use to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.01874; inspect its method and evaluation before treating results as production evidence.,medium,README.md,872,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L872,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.01874,[2607.01874] SkillCoach: Self-Evolving Rubrics for Evaluating and Enhancing Agentic Skill-Use,"Skills are becoming a reusable operational layer for LLM agents, encoding SOPs, domain rules, tool workflows, scripts, and validation routines. In realistic skill repositories, overlapping skills make reliable skill-use difficult. Final verifier success is too coarse for both evaluation and training, since an agent may pass through trial and error while selecting distractor skills, skipping required steps, composing workflows incorrectly or omitting final checks. We introduce SkillCoach, a self-evolving rubric framework for evaluating and enhancing agentic skill-use. SkillCoach derives skill-grounded process rubrics from real rollouts and evaluates trajectories along four dimensions: skill selection, skill following, skill composition, and skill-grounded reflection. It keeps the external verifier as a separate outcome signal, allowing process quality to be distinguished from accidental task success. The evolved rubrics further serve as process supervision for selecting high-quality training trajectories. Experiments show that evolved rubrics substantially improve evaluation quality, expose failures hidden by final accuracy, and provide stronger supervision signals than outcome-only filtering for enhancing agentic skill-use.",Jiayin Zhu; Kelong Mao; Yudong Guo; Dengbo He; Sulong Xu; Simiu Gu; Yutao Yue,2026-07-02,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2607.01874,2026-07-17T17:58:18+00:00 ale-0270,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,SWE-Doctor: Guiding Software Engineering Agents with Runtime Diagnosis from Bug Reproduction Tests,https://arxiv.org/abs/2607.00990,external,arxiv.org,"Shows that naively feeding bug-reproduction tests to software-engineering agents can mislead them, and instead pipes runtime diagnosis from multi-faceted reproduction tests into patch generation, reaching 75.7% on SWE-bench Verified.","Shows that naively feeding bug-reproduction tests to software-engineering agents can mislead them, and instead pipes runtime diagnosis from multi-faceted reproduction tests into patch generation, reaching 75.7% on SWE-bench Verified.","Shows that naively feeding bug-reproduction tests to software-engineering agents can mislead them, and instead pipes runtime diagnosis from multi-faceted reproduction tests into patch generation, reaching 75.7% on SWE-bench Verified.","Verification is promoted from a final check to a loop-control signal. Shows that naively feeding bug-reproduction tests to software-engineering agents can mislead them, and instead pipes runtime diagnosis from multi-faceted reproduction tests into patch generation, reaching 75.7% on SWE-bench Verified.",Use SWE-Doctor: Guiding Software Engineering Agents with Runtime Diagnosis from Bug Reproduction Tests to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.00990; inspect its method and evaluation before treating results as production evidence.,medium,README.md,873,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L873,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.00990,[2607.00990] SWE-Doctor: Guiding Software Engineering Agents with Runtime Diagnosis from Multi-Faceted Bug Reproduction Tests,"Large language model (LLM)-based software engineering agents are increasingly developed to resolve software issues by generating patches from issue reports and code repositories. Bug reproduction tests (BRTs) are an important building block for such agents and have been shown useful for patch validation. However, it remains unclear whether BRTs can also help the more central stage of patch generation. We first conduct a preliminary study and find that directly using advanced BRT generators to guide patch generation is not beneficial: fail-to-fail BRTs can mislead agents, while even fail-to-pass BRTs bring limited or negative gains. Our analysis reveals two reasons: fail-to-pass BRTs may cover only one manifestation of the reported issue, leading to partial patches, whereas fail-to-fail BRTs are unreliable as direct patch-generation targets. Motivated by these insights, we propose SWE-Doctor, a software issue resolution agent that guides patch generation with runtime diagnoses derived from multi-faceted BRT executions. SWE-Doctor first generates multi-faceted BRTs for different behavioral requirements stated in the issue, then executes and debugs these BRTs to construct runtime-grounded diagnosis records, and finally uses the diagnoses together with localization information inferred during BRT generation to guide patch generation and reduce partial patches. We evaluate SWE-Doctor on Python bug-fixing issues from the widely adopted SWE-bench Verified and SWE-bench Pro across five LLM backends. SWE-Doctor consistently outperforms existing agents across all 10 LLM-benchmark combinations, achieving average resolution rates of 75.7% on SWE-bench Verified and 59.4% on SWE-bench Pro. In particular, on the more challenging SWE-bench Pro, SWE-Doctor improves the average resolution rate by 8.0-8.9 percentage points over the baseline agents.",Yaoqi Guo; Yang Liu; Jie M. Zhang; Yun Ma; Yiling Lou; Zhenpeng Chen,2026-07-01,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.00990,2026-07-17T17:58:18+00:00 @@ -276,7 +276,7 @@ ale-0274,Verification And Feedback Gates,verification-and-feedback-gates,Paper, ale-0275,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,LLM-as-a-Verifier: A General-Purpose Verification Framework,https://arxiv.org/abs/2607.05391,external,arxiv.org,"Treats verification as a scaling axis and builds a training-free framework that computes continuous scores from token logits for fine-grained agentic feedback, scaled via score granularity, repeated evaluation, and criteria decomposition.","Treats verification as a scaling axis and builds a training-free framework that computes continuous scores from token logits for fine-grained agentic feedback, scaled via score granularity, repeated evaluation, and criteria decomposition.","Treats verification as a scaling axis and builds a training-free framework that computes continuous scores from token logits for fine-grained agentic feedback, scaled via score granularity, repeated evaluation, and criteria decomposition.","Verification is promoted from a final check to a loop-control signal. Treats verification as a scaling axis and builds a training-free framework that computes continuous scores from token logits for fine-grained agentic feedback, scaled via score granularity, repeated evaluation, and criteria decomposition.",Use LLM-as-a-Verifier: A General-Purpose Verification Framework to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.05391; inspect its method and evaluation before treating results as production evidence.,medium,README.md,878,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L878,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;budget,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.05391,[2607.05391] LLM-as-a-Verifier: A General-Purpose Verification Framework,"Scaling pre-training, post-training, and test-time compute have become the central paradigms for improving the capabilities of LLMs. In this work, we identify verification, the ability to determine the correctness of a solution, as a new scaling axis. To unlock this and demonstrate its effectiveness, we introduce LLM-as-a-Verifier, a general-purpose verification framework that provides fine-grained feedback for agentic tasks without requiring additional training. Unlike standard LM judges that prompt LLMs to produce discrete scores for candidate solutions, LLM-as-a-Verifier computes the expectation over the distribution of scoring token logits to generate continuous scores. This probabilistic formulation enables verification to scale along multiple dimensions: (1) score granularity, (2) repeated evaluation, and (3) criteria decomposition. In particular, we show that scaling the scoring granularity leads to better separation between positive and negative solutions, resulting in more calibrated comparisons. Moreover, scaling repeated evaluation and criteria decomposition consistently lead to additional gains in verification accuracy through variance and complexity reduction. We further introduce a cost-efficient ranking algorithm for selecting the best solution among candidates using the verifier's continuous scores. LLM-as-a-Verifier achieves state-of-the-art performance on Terminal-Bench V2 (86.5%), SWE-Bench Verified (78.2%), RoboRewardBench (87.4%), and MedAgentBench (73.3%). Beyond verification, the fine-grained signals from LLM-as-a-Verifier can also serve as a proxy for estimating task progress. We build an extension for Claude Code, enabling developers to monitor and improve their own agentic systems. Finally, we show that LLM-as-a-Verifier can provide dense feedback for RL, improving the sample efficiency of SAC and GRPO on robotics and mathematical reasoning benchmarks.",Jacky Kwok; Shulu Li; Pranav Atreya; Yuejiang Liu; Yixing Jiang; Chelsea Finn; Marco Pavone; Ion Stoica; Azalia Mirhoseini,2026-07-06,2026,arXiv,arXiv,,Code: https://github.com/llm-as-a-verifier/llm-as-a-verifier Website: https://llm-as-a-verifier.com,cs.AI,arxiv-api,,,,,,,2607.05391,2026-07-17T17:58:18+00:00 ale-0276,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,From Prompts to Contracts: Harness Engineering for Auditable Enterprise LLM Agents,https://arxiv.org/abs/2607.08028,external,arxiv.org,"Moves deterministic agent behavior out of prompts into code, schemas, and behavior contracts, wrapping validation around a replaceable model boundary so enterprise agents remain auditable and safe across model substitutions.","Moves deterministic agent behavior out of prompts into code, schemas, and behavior contracts, wrapping validation around a replaceable model boundary so enterprise agents remain auditable and safe across model substitutions.","Moves deterministic agent behavior out of prompts into code, schemas, and behavior contracts, wrapping validation around a replaceable model boundary so enterprise agents remain auditable and safe across model substitutions.","Treats feedback, telemetry, and deterministic artifacts as loop-control gates. Moves deterministic agent behavior out of prompts into code, schemas, and behavior contracts, wrapping validation around a replaceable model boundary so enterprise agents remain auditable and safe across model substitutions.",Use From Prompts to Contracts: Harness Engineering for Auditable Enterprise LLM Agents to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.08028; inspect its method and evaluation before treating results as production evidence.,medium,README.md,879,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L879,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.08028,[2607.08028] From Prompts to Contracts: Harness Engineering for Auditable Enterprise LLM Agents,"Enterprise large language model (LLM) applications often begin as prototypes whose behavior is carried by prompts and retrieval context. Productization adds requirements for source boundaries, entity routing, answer contracts, and reproducible traces. We present a harness-engineering approach that reconstructs this pattern into a traceable, auditable LLM-agent architecture: deterministic behavior moves into code, manifests, schemas, and validation artifacts around a replaceable composition boundary, while source-backed claims remain the authority for runtime answers. We instantiate it on a public-data slice of five Korean corporate groups (25 listed companies) and evaluate three research questions. (1) The harness preserves its source-grounding, entity-routing, trace, output-hygiene, and recommendation-language contracts across the fixed validation scenarios; a fault-injection control confirms the validators flag deliberately broken contracts. (2) The checks the harness enforces held under model substitution: across three hosted models, they passed on all 270 composition-boundary runs; failures were confined to the model-composed side and were caught and recorded. (3) The code-owned guarantees are load-bearing, not reproducible by prompting alone: holding the model fixed and varying only the enforcement layer, prompt instructions alone let recommendation-language and internal-trace-leakage violations reach the reader, which the harness blocks entirely. A bolt-on external guardrail prevents such violations too but over-refuses, dropping utility to 88/120 where the harness preserves full utility (120/120); in this ablation, only code-owned enforcement preserves both safety and utility. The result is a reusable engineering pattern for turning exploratory prototypes into auditable applications with versioned source, control, and validation artifacts.",Joongho Ahn; Moonsoo Kim,2026-07-09,2026,arXiv,arXiv,,"32 pages, 6 figures, 16 tables. Reference implementation and evaluation artifacts: https://github.com/hammerbaki/enterprise-llm-agent-harness (archived at https://doi.org/10.5281/zenodo.21269426)",cs.AI,arxiv-api,,,,,,,2607.08028,2026-07-17T17:58:18+00:00 ale-0277,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,From Noisy Traces to Root Causes: Structural Trajectory Analysis and Causal Extraction for Agent Optimization,https://arxiv.org/abs/2607.07702,external,arxiv.org,"STRACE structures redundant, heterogeneous agent execution traces by mining batch-level failure patterns and performing causal localization over a textual dependency graph, handing root causes rather than noisy trajectories to the reflection-based optimizer and lifting success on a formal verification task from 42.5% to 58.5%.","STRACE structures redundant, heterogeneous agent execution traces by mining batch-level failure patterns and performing causal localization over a textual dependency graph, handing root causes rather than noisy trajectories to the reflection-based optimizer and lifting success on a formal verification task from 42.5% to 58.5%.","STRACE structures redundant, heterogeneous agent execution traces by mining batch-level failure patterns and performing causal localization over a textual dependency graph, handing root causes rather than noisy trajectories to the reflection-based optimizer and lifting success on a formal verification task from 42.5% to 58.5%.","Control flow is represented as an inspectable graph rather than an opaque prompt loop. STRACE structures redundant, heterogeneous agent execution traces by mining batch-level failure patterns and performing causal localization over a textual dependency graph, handing root causes rather than noisy trajectories to the reflection-based optimizer and lifting success on a formal verification task from 42.5% to 58.5%.",Use From Noisy Traces to Root Causes: Structural Trajectory Analysis and Causal Extraction for Agent Optimization to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.07702; inspect its method and evaluation before treating results as production evidence.,medium,README.md,880,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L880,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.07702,[2607.07702] From Noisy Traces to Root Causes: Structural Trajectory Analysis and Causal Extraction for Agent Optimization,"The optimization of long-horizon agents increasingly relies on reflection-based mechanisms, where a large language model (LLM) acts as an optimizer to diagnose agent failures and improve agent policies. However, real execution traces are difficult to use directly for optimization: large trace collections are often redundant and heterogeneous, making optimization inefficient and prone to overfitting to low-value failures; meanwhile, each individual trajectory also contains many irrelevant steps, while naive context reduction methods such as truncation or sliding windows can discard causally important evidence and produce misleading optimization signals. To resolve this dilemma, we introduce STRACE (Structural TRajectory Analysis and Causal Extraction), a framework that constructs high signal-noise optimization contexts for more precise and effective optimization. At the batch level, STRACE mines failure patterns to filter redundant traces and retain representative failures; within each selected trace, it performs causal localization over a textual dependency graph to remove non-causal steps and identify the true root-cause module for optimization. Empirical results demonstrate that STRACE significantly outperforms standard context-filtering baselines. Notably, on a challenging formal verification task (VeruSAGE-Bench), it successfully optimizes human-expert designed agents, delivering $1.4\times$ success-rate improvement (42.5% to 58.5%). The code is available at https://github.com/moomight/STRACE .",Ying Chang; Jiahang Xu; Xuan Feng; Chenyuan Yang; Peng Cheng; Yuqing Yang,2026-07-08,2026,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,2607.07702,2026-07-17T17:58:18+00:00 -ale-0278,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Who Broke the System? Failure Localization in LLM-Based Multi-Agent Systems,https://arxiv.org/abs/2607.07989,external,arxiv.org,"AgentLocate attributes failures in LLM multi-agent trajectories to both the responsible agent and the earliest decisive step, pairing LLM-based evaluation with independent assessor verification and confidence-weighted aggregation to outperform prior attribution methods on two benchmarks, the diagnose side of the verify step for dispatched-agent loops.","AgentLocate attributes failures in LLM multi-agent trajectories to both the responsible agent and the earliest decisive step, pairing LLM-based evaluation with independent assessor verification and confidence-weighted aggregation to outperform prior attribution methods on two benchmarks, the diagnose side of the verify step for dispatched-agent loops.","AgentLocate attributes failures in LLM multi-agent trajectories to both the responsible agent and the earliest decisive step, pairing LLM-based evaluation with independent assessor verification and confidence-weighted aggregation to outperform prior attribution methods on two benchmarks, the diagnose side of the verify step for dispatched-agent loops.","Verification is promoted from a final check to a loop-control signal. AgentLocate attributes failures in LLM multi-agent trajectories to both the responsible agent and the earliest decisive step, pairing LLM-based evaluation with independent assessor verification and confidence-weighted aggregation to outperform prior attribution methods on two benchmarks, the diagnose side of the verify step for dispatched-agent loops.",Use Who Broke the System? Failure Localization in LLM-Based Multi-Agent Systems to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.07989; inspect its method and evaluation before treating results as production evidence.,medium,README.md,881,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L881,,Verify,verify,"Gate progress with tests, evals, and evidence.",delegation;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.07989,[2607.07989] Who Broke the System? Failure Localization in LLM-Based Multi-Agent Systems,"Large language model (LLM) based multi-agent systems enable complex problem solving through coordinated reasoning and action, but their distributed structure also introduces new challenges in diagnosing system-level failures. When an execution fails, identifying which agent is responsible and at what point the trajectory first becomes irreversibly misdirected is difficult due to long-horizon interactions and tightly coupled agent behaviors. In this paper, we study the problem of failure localization in LLM-based multi-agent systems and present AgentLocate, a framework that attributes failures to both a specific agent and the earliest decisive step. AgentLocate combines an LLM-based judging mechanism with multi-perspective verification by independent evaluators, whose assessments are aggregated using a confidence-aware strategy. The resulting feedback is further used to adapt the judge through lightweight fine-tuning, improving attribution quality. We evaluate AgentLocate on two complementary benchmarks covering diverse tasks, agent configurations, and trajectory lengths. Experimental results show that AgentLocate consistently outperforms existing failure localization methods in identifying both responsible agents and failure steps, while remaining efficient in terms of token usage and running time.",Yufei Xia; Anjun Gao; Yueyang Quan; Zhuqing Liu; Minghong Fang,2026-07-08,2026,arXiv,arXiv,,To appear in COLM 2026,cs.CR,arxiv-api,,,,,,,2607.07989,2026-07-17T17:58:18+00:00 +ale-0278,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Who Broke the System? Failure Localization in LLM-Based Multi-Agent Systems,https://arxiv.org/abs/2607.07989,external,arxiv.org,"AgentLocate attributes failures in LLM multi-agent trajectories to both the responsible agent and the earliest decisive step, pairing LLM-based evaluation with independent assessor verification and confidence-weighted aggregation to outperform prior attribution methods on two benchmarks, the diagnose side of the verify step for dispatched-agent loops.","AgentLocate attributes failures in LLM multi-agent trajectories to both the responsible agent and the earliest decisive step, pairing LLM-based evaluation with independent assessor verification and confidence-weighted aggregation to outperform prior attribution methods on two benchmarks, the diagnose side of the verify step for dispatched-agent loops.","AgentLocate attributes failures in LLM multi-agent trajectories to both the responsible agent and the earliest decisive step, pairing LLM-based evaluation with independent assessor verification and confidence-weighted aggregation to outperform prior attribution methods on two benchmarks, the diagnose side of the verify step for dispatched-agent loops.","Verification is promoted from a final check to a loop-control signal. AgentLocate attributes failures in LLM multi-agent trajectories to both the responsible agent and the earliest decisive step, pairing LLM-based evaluation with independent assessor verification and confidence-weighted aggregation to outperform prior attribution methods on two benchmarks, the diagnose side of the verify step for dispatched-agent loops.",Use Who Broke the System? Failure Localization in LLM-Based Multi-Agent Systems to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.07989; inspect its method and evaluation before treating results as production evidence.,medium,README.md,881,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L881,,Verify,verify,"Gate progress with tests, evals, and evidence.",delegation;verification,researcher;evaluator,research-paper,ok,https://arxiv.org/abs/2607.07989,[2607.07989] Who Broke the System? Failure Localization in LLM-Based Multi-Agent Systems,"Large language model (LLM) based multi-agent systems enable complex problem solving through coordinated reasoning and action, but their distributed structure also introduces new challenges in diagnosing system-level failures. When an execution fails, identifying which agent is responsible and at what point the trajectory first becomes irreversibly misdirected is difficult due to long-horizon interactions and tightly coupled agent behaviors. In this paper, we study the problem of failure localization in LLM-based multi-agent systems and present AgentLocate, a framework that attributes failures to both a specific agent and the earliest decisive step. AgentLocate combines an LLM-based judging mechanism with multi-perspective verification by independent evaluators, whose assessments are aggregated using a confidence-aware strategy. The resulting feedback is further used to adapt the judge through lightweight fine-tuning, improving attribution quality. We evaluate AgentLocate on two complementary benchmarks covering diverse tasks, agent configurations, and trajectory lengths. Experimental results show that AgentLocate consistently outperforms existing failure localization methods in identifying both responsible agents and failure steps, while remaining efficient in terms of token usage and running time.",Yufei Xia; Anjun Gao; Yueyang Quan; Zhuqing Liu; Minghong Fang,2026,2026,Conference on Language Modeling (COLM),Conference on Language Modeling,,Accepted at Conference on Language Modeling (COLM); the linked arXiv record is the available paper version.,cs.CR,Official COLM accepted-papers list and current arXiv note,,,,,,,2607.07989,2026-07-17T17:58:18+00:00 ale-0279,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,3100 Opinions on Code Review in an AI World: Building Causal Theory from Practitioner Discourse,https://arxiv.org/abs/2607.07980,external,arxiv.org,"Builds a causal theory of 26 constructs and 67 relationships from 3,100 coded practitioner documents on how AI-authored pull requests reshape code review, arguing review is the control point through which a coding agent's effect on software is decided and that outcomes hinge on team expertise and review process structure rather than AI itself.","Builds a causal theory of 26 constructs and 67 relationships from 3,100 coded practitioner documents on how AI-authored pull requests reshape code review, arguing review is the control point through which a coding agent's effect on software is decided and that outcomes hinge on team expertise and review process structure rather than AI itself.","Builds a causal theory of 26 constructs and 67 relationships from 3,100 coded practitioner documents on how AI-authored pull requests reshape code review, arguing review is the control point through which a coding agent's effect on software is decided and that outcomes hinge on team expertise and review process structure rather than AI itself.","Treats feedback, telemetry, and deterministic artifacts as loop-control gates. Builds a causal theory of 26 constructs and 67 relationships from 3,100 coded practitioner documents on how AI-authored pull requests reshape code review, arguing review is the control point through which a coding agent's effect on software is decided and that outcomes hinge on team expertise and review process structure rather than AI itself.",Use 3100 Opinions on Code Review in an AI World: Building Causal Theory from Practitioner Discourse to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.07980; inspect its method and evaluation before treating results as production evidence.,medium,README.md,882,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L882,,Verify,verify,"Gate progress with tests, evals, and evidence.",context,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.07980,[2607.07980] 3100 Opinions on Code Review in an AI World: Building Causal Theory from Practitioner Discourse,"Coding agents now author entire pull requests, and practitioners sharply disagree about what this does to code review: whether it becomes the bottleneck, whether human review is still necessary, and whether it quietly erodes the understanding that it once built. Repository-mining studies measure surface trends but seldom explain the mechanisms beneath them, and the trends themselves prove unstable. A motivating observational analysis of public GITHUB activity finds that agent-authored pull requests are reviewed less often, merged several times faster, and discussed less than human-authored ones, yet the direction of these trends flips under different but equally defensible analysis choices, so the traces establish what is changing without explaining why. To recover the mechanisms, we synthesize practitioner discourse at scale into an explanatory theory: we collect 38,709 grey-literature documents (engineering blogs and Reddit threads), filter to those substantively about code review, and code a stratified random sample of 3,100 with an LLM-assisted pipeline, from which we build a causal model of 26 constructs and 67 relationships (64 directed, 3 contested). Its organizing claim is that review is the control point through which a coding agent's effect on software is decided, and that AI does not fix the sign of that effect: the team sets it, through the expertise its humans bring and how it structures the review process. The theory makes the competing positions explicit and turns ""AI is changing code review"" into falsifiable propositions with named constructs and moderators. As a secondary contribution, we offer the underlying LLM-assisted, grey-literature theory-building method as a scalable template for software-engineering research, with a public implementation.",Shyam Agarwal; Courtney Miller; Christian KΓ€stner; Bogdan Vasilescu,2026-07-08,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.07980,2026-07-17T17:58:18+00:00 ale-0280,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Persuasion Attacks Can Decrease Effectiveness of CoT Monitoring,https://arxiv.org/abs/2607.08066,external,arxiv.org,"Stress-tests chain-of-thought monitoring as an in-loop safety gate: adversarial agents arguing for policy-violating proposals turn the scratchpad into a persuasion channel, with monitor access to the agent's reasoning increasing approval of harmful actions by 9.5% on average, while pairing monitor and fact-checker from different model families cuts violating approvals by up to 45%.","Stress-tests chain-of-thought monitoring as an in-loop safety gate: adversarial agents arguing for policy-violating proposals turn the scratchpad into a persuasion channel, with monitor access to the agent's reasoning increasing approval of harmful actions by 9.5% on average, while pairing monitor and fact-checker from different model families cuts violating approvals by up to 45%.","Stress-tests chain-of-thought monitoring as an in-loop safety gate: adversarial agents arguing for policy-violating proposals turn the scratchpad into a persuasion channel, with monitor access to the agent's reasoning increasing approval of harmful actions by 9.5% on average, while pairing monitor and fact-checker from different model families cuts violating approvals by up to 45%.","Treats feedback, telemetry, and deterministic artifacts as loop-control gates. Stress-tests chain-of-thought monitoring as an in-loop safety gate: adversarial agents arguing for policy-violating proposals turn the scratchpad into a persuasion channel, with monitor access to the agent's reasoning increasing approval of harmful actions by 9.5% on average, while pairing monitor and fact-checker from different model families cuts violating approvals by up to 45%.",Use Persuasion Attacks Can Decrease Effectiveness of CoT Monitoring to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.08066; inspect its method and evaluation before treating results as production evidence.,medium,README.md,883,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L883,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;escalation,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.08066,[2607.08066] Persuasion Attacks Can Decrease Effectiveness of CoT Monitoring,"Chain-of-thought (CoT) monitoring is a promising safety mechanism for AI agents, based on the premise that visible reasoning traces can surface misaligned or deceptive behavior. While effective in standard scenarios, recent work highlights that LLMs remain vulnerable to persuasion-based jailbreaks, where natural-language arguments override model constraints. We stress-test whether this vulnerability extends to monitoring LLMs: can an adversarial agent persuade its CoT monitor to approve proposed actions that violate the monitor's policy? We design an evaluation framework with 40 tasks and analyze thousands of agent-monitor interactions, where agents are instructed to argue for policy-violating proposals. We find that in such adversarial settings, monitor access to the agent's CoT reasoning increases rather than decreases approval of harmful actions on average by 9.5%, as the scratchpad provides an additional persuasion channel. To address this, we introduce a fact-checking monitoring framework. We find that a fact-checker and monitor pairing from different model families, for example a Claude 3.7 Sonnet monitor paired with a GPT-4.1 fact-checker, reduces approval of policy-violating actions by up to 45%, compared to only 6%, when using the same model for both fact-checking and monitoring roles. Our results demonstrate that CoT monitoring alone may be insufficient against adversarial persuasion, and that model-diverse fact-checking provides a robust mitigation.",Jennifer Za; Julija Bainiaksina; Nikita Ostrovsky; Tanush Chopra; Victoria Krakovna,2026-07-09,2026,arXiv,arXiv,,"25 pages, 10 figures",cs.AI,arxiv-api,,,,,,,2607.08066,2026-07-17T17:58:18+00:00 ale-0281,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Physics-Audited Agentic Discovery in Scientific Machine Learning,https://arxiv.org/abs/2607.07379,external,arxiv.org,"Verification-first workflow (PA-SciML) for agentic model discovery in scientific ML: fixes the scoring evaluator before search, derives machine-checkable physics requirements (boundary conditions, superposition, stiffness scaling, causality), audits every trained candidate's predicted fields against them, and separately searches prescribed input ranges for high-violation cases, reporting a surrogate as verified only under the stated checks; a domain-specific case of verification-gated agentic search.","Verification-first workflow (PA-SciML) for agentic model discovery in scientific ML: fixes the scoring evaluator before search, derives machine-checkable physics requirements (boundary conditions, superposition, stiffness scaling, causality), audits every trained candidate's predicted fields against them, and separately searches prescribed input ranges for high-violation cases, reporting a surrogate as verified only under the stated checks; a domain-specific case of verification-gated agentic search.","Verification-first workflow (PA-SciML) for agentic model discovery in scientific ML: fixes the scoring evaluator before search, derives machine-checkable physics requirements (boundary conditions, superposition, stiffness scaling, causality), audits every trained candidate's predicted fields against them, and separately searches prescribed input ranges for high-violation cases, reporting a surrogate as verified only under the stated checks; a domain-specific case of verification-gated agentic search.","Verification is promoted from a final check to a loop-control signal. Verification-first workflow (PA-SciML) for agentic model discovery in scientific ML: fixes the scoring evaluator before search, derives machine-checkable physics requirements (boundary conditions, superposition, stiffness scaling, causality), audits every trained candidate's predicted fields against them, and separately searches prescribed input ranges for high-violation cases, reporting a surrogate as verified only under the stated checks; a domain-specific case of verification-gated agentic search.",Use Physics-Audited Agentic Discovery in Scientific Machine Learning to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.07379; inspect its method and evaluation before treating results as production evidence.,medium,README.md,884,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L884,,Verify,verify,"Gate progress with tests, evals, and evidence.",intake;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.07379,[2607.07379] Physics-Audited Agentic Discovery in Scientific Machine Learning,"In agentic scientific machine learning (SciML), large language model (LLM) agents can discover surrogate models and select one by an automated score, typically an error metric. A low error, however, does not establish that the predicted fields satisfy the physics that matter for mechanics, such as boundary conditions, superposition, stiffness scaling, or causality. We introduce Physics-Audited Agentic SciML (PA-SciML), a verification-first workflow for agentic SciML discovery. The workflow fixes a scoring evaluator before search, derives reviewable machine-checkable physics requirements, checks each trained candidate on its outputs, and separately searches prescribed input ranges or measured load-history spans for high-violation cases without reference solution fields. A surrogate is reported as verified only under the stated checks. When enabled, the workflow also adds advisory numerical probes before training and tests one modeling change at a time to record which isolated edits are associated with score gains before reuse. In the reported computational-solid-mechanics numerical examples, the static elasticity run selects a surrogate with lower validation error than the error-only baseline while both selected models pass the common linear-elastic checks. In the transient elastodynamics run, an error-only baseline with similar mean error fails a stricter causality check by responding to future parts of the loading history, while the selected surrogate passes the stated checks. The main distinction is per-candidate physics evidence on predicted fields, not a richer aggregate score.",Diab W. Abueidda; Bilal Ahmed; Panos Pantidis; Mostafa E. Mobasher,2026-07-08,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2607.07379,2026-07-17T17:58:18+00:00 @@ -287,7 +287,7 @@ ale-0285,Verification And Feedback Gates,verification-and-feedback-gates,Paper, ale-0286,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Latent Programming Horizons in Coding Agents,https://arxiv.org/abs/2607.05188,external,arxiv.org,"Shows a coding agent's hidden states linearly encode program properties like correctness and test outcomes and predict future edits up to 25 steps ahead, a latent signal that could gate or steer verification loops before edits materialize.","Shows a coding agent's hidden states linearly encode program properties like correctness and test outcomes and predict future edits up to 25 steps ahead, a latent signal that could gate or steer verification loops before edits materialize.","Shows a coding agent's hidden states linearly encode program properties like correctness and test outcomes and predict future edits up to 25 steps ahead, a latent signal that could gate or steer verification loops before edits materialize.","Verification is promoted from a final check to a loop-control signal. Shows a coding agent's hidden states linearly encode program properties like correctness and test outcomes and predict future edits up to 25 steps ahead, a latent signal that could gate or steer verification loops before edits materialize.",Use Latent Programming Horizons in Coding Agents to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.05188; inspect its method and evaluation before treating results as production evidence.,medium,README.md,889,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L889,2026-07-15,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.05188,[2607.05188] Latent Programming Horizons in Coding Agents,"A coding agent solving a software-engineering task spends dozens of steps reasoning, editing code, and running tests, yet little is known about what the underlying language model internally represents about the program it is working on. We show that the residual streams of language models under coding agents linearly encode properties of the evolving program: a logistic-regression probe on hidden states is able to decode whether the current code parses, passes its test suite, reduces the number of failing tests, and introduces regressions, reaching AUC up to 0.83 for correctness across two models and two benchmarks. Our second finding is more surprising: these representations run ahead of the agent's own edits. Probes trained to predict the outcome of future edits (before they are materialized and written on disk) achieve performance above chance up to roughly 25 steps in advance. We call this the agent's latent programming horizon. As a proof of external validity, we show that the probes transfer across benchmarks without retraining. Our positive results open calls for more research in mechanistic interpretability of coding agents.",AndrΓ© Silva; Han Tu; Martin Monperrus,2026-07-06,2026,arXiv,arXiv,,,cs.LG,arxiv-api,,,,,,,2607.05188,2026-07-17T17:58:18+00:00 ale-0287,Verification And Feedback Gates,verification-and-feedback-gates,Docs,πŸ“š,Why evaluate agents,https://adk.dev/evaluate/,external,adk.dev,"Official ADK guide to evaluating final responses and trajectories, defining test cases, selecting criteria, and running repeatable agent evaluations locally or in CI.","Official ADK guide to evaluating final responses and trajectories, defining test cases, selecting criteria, and running repeatable agent evaluations locally or in CI.","Official ADK guide to evaluating final responses and trajectories, defining test cases, selecting criteria, and running repeatable agent evaluations locally or in CI.","Primary-source operational guidance rather than commentary. Official ADK guide to evaluating final responses and trajectories, defining test cases, selecting criteria, and running repeatable agent evaluations locally or in CI.",Use Why evaluate agents to measure progress and gate completion with repeatable evidence.,Primary official documentation from adk.dev; use it for current product or standard behavior.,high,README.md,890,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L890,2026-07-17,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,builder;evaluator,official-documentation,ok,https://adk.dev/evaluate/,Why evaluate agents - Agent Development Kit (ADK) Agent Development Kit (ADK),Build powerful multi-agent systems with Agent Development Kit (ADK),Google Agent Development Kit,,,Google Agent Development Kit,Google,,,,primary-page,,,,,,,,2026-07-17T17:58:18+00:00 ale-0288,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Structured Feedback Improves Repair in an LLM Agent Loop,https://arxiv.org/abs/2607.14167,external,arxiv.org,"In 50 paired TextWorld tasks under a four-call budget, feedback containing the failure location, observed value, and admissible alternatives raises repair success from 14/50 to 36/50 for one model and 8/50 to 29/50 for another; ablations identify alternatives, not JSON syntax, as the main driver.","In 50 paired TextWorld tasks under a four-call budget, feedback containing the failure location, observed value, and admissible alternatives raises repair success from 14/50 to 36/50 for one model and 8/50 to 29/50 for another; ablations identify alternatives, not JSON syntax, as the main driver.","In 50 paired TextWorld tasks under a four-call budget, feedback containing the failure location, observed value, and admissible alternatives raises repair success from 14/50 to 36/50 for one model and 8/50 to 29/50 for another; ablations identify alternatives, not JSON syntax, as the main driver.","The contribution is machine-readable and validation-friendly. In 50 paired TextWorld tasks under a four-call budget, feedback containing the failure location, observed value, and admissible alternatives raises repair success from 14/50 to 36/50 for one model and 8/50 to 29/50 for another; ablations identify alternatives, not JSON syntax, as the main driver.",Use Structured Feedback Improves Repair in an LLM Agent Loop to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.14167; inspect its method and evaluation before treating results as production evidence.,medium,README.md,891,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L891,2026-07-17,Verify,verify,"Gate progress with tests, evals, and evidence.",budget,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.14167,[2607.14167] Structured Feedback Improves Repair in an LLM Agent Loop,"LLM agents often retry after external validation rejects a candidate, but the interface between validation and the next model call remains underspecified. We introduce VeriHarness, a code-controlled agent loop in which models generate candidates while external validators control acceptance, budgets, and traces. We use it to compare raw diagnostics with feedback that identifies the failure location, observed value, and admissible alternatives. Across 50 paired TextWorld games under a four-call cap, feedback containing all three fields raises terminal success from 14/50 to 36/50 for Qwen2.5-Coder-14B (+44 percentage points) and from 8/50 to 29/50 for Llama-3.1-8B (+42 points). Ablations locate most of the gain in the admissible alternatives: feedback containing only the location and observed value remains near the raw diagnostic baseline. Presenting the complete repair information in prose instead of a keyed JSON record yields nearly the same success, providing no evidence that JSON syntax itself improves repair. The ordering persists across the tested call budgets and one sampled-decoding setting.",Jaideep Ray; Ankit Goyal,2026-07-15,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.14167,2026-07-17T17:58:18+00:00 -ale-0289,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Copy-on-Write Scoring: Application-Specific Agent Evaluations,https://arxiv.org/abs/2607.14336,external,arxiv.org,Uses PostgreSQL copy-on-write isolation to let an agent modify a realistic application state while a scorer evaluates the resulting operations safely; the Plane case study also exposes tool-surface defects that simpler task checks miss.,Uses PostgreSQL copy-on-write isolation to let an agent modify a realistic application state while a scorer evaluates the resulting operations safely; the Plane case study also exposes tool-surface defects that simpler task checks miss.,Uses PostgreSQL copy-on-write isolation to let an agent modify a realistic application state while a scorer evaluates the resulting operations safely; the Plane case study also exposes tool-surface defects that simpler task checks miss.,State persistence is explicit enough for repeated runs and handoff. Uses PostgreSQL copy-on-write isolation to let an agent modify a realistic application state while a scorer evaluates the resulting operations safely; the Plane case study also exposes tool-surface defects that simpler task checks miss.,Use Copy-on-Write Scoring: Application-Specific Agent Evaluations to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.14336; inspect its method and evaluation before treating results as production evidence.,medium,README.md,892,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L892,2026-07-17,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.14336,[2607.14336] Copy-on-Write Scoring: Application-Specific Agent Evaluations,"Trustworthy deployment of LLM-based agents in software systems requires evaluating how they perform on application-specific workflows, with enough granularity to localize where they succeed and fail. Yet existing agent evaluation mechanisms are limited: benchmarks have low construct validity for application-specific workflows and environments, and replica evaluation environments are expensive and prone to drift. We propose Copy-on-Write (CoW) Scoring, a framework that evaluates agent operations directly within application environments using a PostgreSQL-level Copy-on-Write mechanism to isolate agent writes. CoW Scoring produces session- and operation-level scores that highlight where agents' database write operations succeed and fail in a given application environment, enabling inexpensive evaluation and iteration on agent harnesses and tool surfaces. We demonstrate the framework on Plane, an open-source project-management platform, where analysis surfaced specific issues in the tool surface, and corresponding fixes produced measurable improvements on affected models. Python library: https://github.com/trail-ml/agent-cow-python",Joanna Roy; Sven Hoelzel,2026-07-15,2026,arXiv,arXiv,,"15 pages, 11 figures, accepted at ICML 2026 Second Workshop on Agents in the Wild: Safety, Security, and Beyond",cs.SE,arxiv-api,,,,,,,2607.14336,2026-07-17T17:58:18+00:00 +ale-0289,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,Copy-on-Write Scoring: Application-Specific Agent Evaluations,https://arxiv.org/abs/2607.14336,external,arxiv.org,Uses PostgreSQL copy-on-write isolation to let an agent modify a realistic application state while a scorer evaluates the resulting operations safely; the Plane case study also exposes tool-surface defects that simpler task checks miss.,Uses PostgreSQL copy-on-write isolation to let an agent modify a realistic application state while a scorer evaluates the resulting operations safely; the Plane case study also exposes tool-surface defects that simpler task checks miss.,Uses PostgreSQL copy-on-write isolation to let an agent modify a realistic application state while a scorer evaluates the resulting operations safely; the Plane case study also exposes tool-surface defects that simpler task checks miss.,State persistence is explicit enough for repeated runs and handoff. Uses PostgreSQL copy-on-write isolation to let an agent modify a realistic application state while a scorer evaluates the resulting operations safely; the Plane case study also exposes tool-surface defects that simpler task checks miss.,Use Copy-on-Write Scoring: Application-Specific Agent Evaluations to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.14336; inspect its method and evaluation before treating results as production evidence.,medium,README.md,892,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L892,2026-07-17,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace;state,researcher;evaluator,research-paper,ok,https://arxiv.org/abs/2607.14336,[2607.14336] Copy-on-Write Scoring: Application-Specific Agent Evaluations,"Trustworthy deployment of LLM-based agents in software systems requires evaluating how they perform on application-specific workflows, with enough granularity to localize where they succeed and fail. Yet existing agent evaluation mechanisms are limited: benchmarks have low construct validity for application-specific workflows and environments, and replica evaluation environments are expensive and prone to drift. We propose Copy-on-Write (CoW) Scoring, a framework that evaluates agent operations directly within application environments using a PostgreSQL-level Copy-on-Write mechanism to isolate agent writes. CoW Scoring produces session- and operation-level scores that highlight where agents' database write operations succeed and fail in a given application environment, enabling inexpensive evaluation and iteration on agent harnesses and tool surfaces. We demonstrate the framework on Plane, an open-source project-management platform, where analysis surfaced specific issues in the tool surface, and corresponding fixes produced measurable improvements on affected models. Python library: https://github.com/trail-ml/agent-cow-python",Joanna Roy; Sven Hoelzel,2026,2026,ICML Workshop on Agents in the Wild: Safety Security and Beyond,International Conference on Machine Learning,,Accepted at ICML Workshop on Agents in the Wild: Safety Security and Beyond; the linked arXiv record is the available paper version.,cs.SE,Current arXiv acceptance note and official workshop page,,,,,,,2607.14336,2026-07-17T17:58:18+00:00 ale-0290,Verification And Feedback Gates,verification-and-feedback-gates,Paper,πŸ“„,The Prover Is the Judge: Verified Security Software from AI Coding Agents in Ada/SPARK,https://arxiv.org/abs/2607.14340,external,arxiv.org,"Places formal proof obligations inside a coding-agent repair loop and reports 49,280 discharged obligations with 20-40x less supervision; the paper also states that proofs must be paired with known-answer tests, interoperability checks, and human specification review.","Places formal proof obligations inside a coding-agent repair loop and reports 49,280 discharged obligations with 20-40x less supervision; the paper also states that proofs must be paired with known-answer tests, interoperability checks, and human specification review.","Places formal proof obligations inside a coding-agent repair loop and reports 49,280 discharged obligations with 20-40x less supervision; the paper also states that proofs must be paired with known-answer tests, interoperability checks, and human specification review.","Verification is promoted from a final check to a loop-control signal. Places formal proof obligations inside a coding-agent repair loop and reports 49,280 discharged obligations with 20-40x less supervision; the paper also states that proofs must be paired with known-answer tests, interoperability checks, and human specification review.",Use The Prover Is the Judge: Verified Security Software from AI Coding Agents in Ada/SPARK to measure progress and gate completion with repeatable evidence.,Research source arXiv:2607.14340; inspect its method and evaluation before treating results as production evidence.,medium,README.md,893,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L893,2026-07-17,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;escalation,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.14340,[2607.14340] The Prover Is the Judge: Verified Security Software from AI Coding Agents in Ada/SPARK,"AI coding agents produce code faster than humans can review it. In our approach, the prover is the judge of whether the code is correct. Under a verifier-driven loop, AI agents wrote and verified bare-metal security software in Ada/SPARK spanning classical and post-quantum cryptography, TLS 1.3, IKEv2, X.509, and a Matrix client. GNATprove discharged 49,280 proof obligations, established functional correctness for selected primitives, and proved the absence of run-time errors for the rest, at roughly 20-40 times lower supervision cost than comparable hand verification. GNATprove alone was insufficient: some defects could not be detected and were resolved using known-answer tests, interoperability, or human review of specifications. Given weak checks, the agent tried to bypass them and reported success. We report where each layer caught faults and draw the central lesson: what an agent can be trusted to establish is bounded by the strength of its feedback.",Tobias Philipp,2026-07-15,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.14340,2026-07-17T17:58:18+00:00 ale-0291,Securing Unattended Loops,securing-unattended-loops,Critique,⚠️,The lethal trifecta for AI agents,https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/,external,simonwillison.net,"Simon Willison's rule of thumb: private data, untrusted content, and an exfiltration channel must never meet inside one unattended agent.","Simon Willison's rule of thumb: private data, untrusted content, and an exfiltration channel must never meet inside one unattended agent.","Simon Willison's rule of thumb: private data, untrusted content, and an exfiltration channel must never meet inside one unattended agent.","Untrusted intake is treated as a loop-level security boundary. Simon Willison's rule of thumb: private data, untrusted content, and an exfiltration channel must never meet inside one unattended agent.",Use The lethal trifecta for AI agents to bound risk before recurring or unattended execution.,"Contextual source from simonwillison.net; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,901,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L901,,Govern,govern,"Bound permissions, cost, failure, and escalation.",workspace;budget;escalation,operator;security,risk-analysis,ok,https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/,"The lethal trifecta for AI agents: private data, untrusted content, and external communication",If you are a user of LLM systems that use tools (you can call them β€œAI agents” if you like) it is critically important that you understand the risk of …,Simon Willison,,2025,,Simon Willison’s Weblog,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0292,Securing Unattended Loops,securing-unattended-loops,Critique,⚠️,Prompt injection series,https://simonwillison.net/series/prompt-injection/,external,simonwillison.net,Ongoing series on the core unsolved vulnerability for loops whose intake includes content written by strangers.,Ongoing series on the core unsolved vulnerability for loops whose intake includes content written by strangers.,Ongoing series on the core unsolved vulnerability for loops whose intake includes content written by strangers.,Untrusted intake is treated as a loop-level security boundary. Ongoing series on the core unsolved vulnerability for loops whose intake includes content written by strangers.,Use Prompt injection series to bound risk before recurring or unattended execution.,"Contextual source from simonwillison.net; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,902,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L902,,Govern,govern,"Bound permissions, cost, failure, and escalation.",intake,operator;security,risk-analysis,ok,https://simonwillison.net/series/prompt-injection/,Simon Willison: Prompt injection,,Simon Willison,,,,Simon Willison’s Weblog,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 @@ -322,7 +322,7 @@ ale-0320,Securing Unattended Loops,securing-unattended-loops,Blog,πŸ“,How We Co ale-0321,Securing Unattended Loops,securing-unattended-loops,Paper,πŸ“„,Rethinking MCP Security: A Large-Scale Study of Runtime MCP Servers and Scanner Reliability,https://arxiv.org/abs/2607.11086,external,arxiv.org,"Large-scale study of live MCP servers finding widespread security weaknesses and that existing MCP security scanners miss or misreport many of them, a gap for anyone gating agent tool access on scanner output.","Large-scale study of live MCP servers finding widespread security weaknesses and that existing MCP security scanners miss or misreport many of them, a gap for anyone gating agent tool access on scanner output.","Large-scale study of live MCP servers finding widespread security weaknesses and that existing MCP security scanners miss or misreport many of them, a gap for anyone gating agent tool access on scanner output.","Frames security as a recurring-loop boundary rather than a one-time prompt hygiene issue. Large-scale study of live MCP servers finding widespread security weaknesses and that existing MCP security scanners miss or misreport many of them, a gap for anyone gating agent tool access on scanner output.",Use Rethinking MCP Security: A Large-Scale Study of Runtime MCP Servers and Scanner Reliability to bound risk before recurring or unattended execution.,Research source arXiv:2607.11086; inspect its method and evaluation before treating results as production evidence.,medium,README.md,931,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L931,2026-07-15,Govern,govern,"Bound permissions, cost, failure, and escalation.",workspace,researcher;evaluator;operator;security,research-preprint,ok,https://arxiv.org/abs/2607.11086,[2607.11086] Rethinking MCP Security: A Large-Scale Study of Runtime MCP Servers and Security Scanner Reliability,"The Model Context Protocol (MCP) has rapidly established itself as a standard interface for enabling LLM-based agents to interact with external tools and services. As MCP servers are increasingly entrusted with security-sensitive operations, understanding their real-world risks has become critical. In practice, due to the absence of large-scale runtime MCP servers, such understanding largely relies on security scanners applied to a small number of cases, yet the reliability of these assessments remains unclear. In this study, we revisit how MCP security is measured. We present MCPZoo, the largest collection of MCP servers for dynamic analysis to date. MCPZoo is constructed through a multi-agent framework for transforming in-the-wild static repositories into dynamic services. The framework emulates how human experts build, diagnose, and iteratively repair deployment and runtime defects by combining environment inference with feedback-driven refinement. To ensure practical interactivity at runtime, the servers are validated via real protocol interactions. As a result, MCPZoo contains 64,611 unique MCP servers (113,927 in total), with more than 37,288 supporting dynamic analysis. Leveraging MCPZoo, we conduct the first ecosystem-scale measurement of MCP servers and the scanners that analyze them. While existing scanners report that 96.89% of servers are risky, we find that these signals are unreliable. In particular, manual validation shows that less than 50% of sampled alerts are true positives, and scanner outputs exhibit clear inconsistency across scanners. Overall, MCPZoo enables large-scale, reproducible measurement of MCP server security and exposes limitations of current scanning practices. We further release a public query interface to support practical risk assessment of MCP servers.",Pei Chen; Baichao An; Mengying Wu; Binwang Wan; Geng Hong; Jinsong Chen; Xudong Pan; Jiarun Dai; Min Yang,2026-07-13,2026,arXiv,arXiv,,"18 pages, 11 figures, and 10 tables. This article substantially extends the preliminary 3-page MCPZoo dataset release arXiv:2512.15144. Includes appendices",cs.CR,arxiv-api,,,,,,,2607.11086,2026-07-17T17:58:18+00:00 ale-0322,Securing Unattended Loops,securing-unattended-loops,Paper,πŸ“„,Agent Hacks Agent: Autoresearch for Production-Agent Red-Teaming,https://arxiv.org/abs/2607.11698,external,arxiv.org,"Uses an autonomous research loop to red-team production agents, having one agent iteratively discover, reproduce, and refine attacks against another, turning red-teaming itself into a recurring verified loop.","Uses an autonomous research loop to red-team production agents, having one agent iteratively discover, reproduce, and refine attacks against another, turning red-teaming itself into a recurring verified loop.","Uses an autonomous research loop to red-team production agents, having one agent iteratively discover, reproduce, and refine attacks against another, turning red-teaming itself into a recurring verified loop.","Verification is promoted from a final check to a loop-control signal. Uses an autonomous research loop to red-team production agents, having one agent iteratively discover, reproduce, and refine attacks against another, turning red-teaming itself into a recurring verified loop.",Use Agent Hacks Agent: Autoresearch for Production-Agent Red-Teaming to bound risk before recurring or unattended execution.,Research source arXiv:2607.11698; inspect its method and evaluation before treating results as production evidence.,medium,README.md,932,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L932,2026-07-15,Govern,govern,"Bound permissions, cost, failure, and escalation.",intake;verification,researcher;evaluator;operator;security,research-preprint,ok,https://arxiv.org/abs/2607.11698,[2607.11698] Agent Hacks Agent: Autoresearch for Production-Agent Red-Teaming,"Production LLM agents such as Claude Code and Codex operate over untrusted content, files, commands, and workspace state, making safety failures directly actionable. Red-teaming must therefore keep pace with evolving models and tools. Existing approaches mainly optimize attack success and preserve artifacts such as benchmarks, payloads, or attack programs, which record where attacks succeed but not the enabling conditions behind unsafe agent behavior. We study automated red-teaming for production LLM agents using one agentic research environment to discover reusable vulnerability knowledge about another. We present AHA, a falsifiable discovery loop that proposes a vulnerability hypothesis, constructs a falsifier, instantiates a valid attack, executes it in a sandboxed harness, reflects on the trajectory, and promotes confirmed findings into a Vulnerability Concept Graph (VCG). Each concept links an attacker-facing surface to an unsafe trajectory through a claim, enabling condition, falsifier, transfer prediction, and supporting evidence. Across Claude Code and Codex on three scenarios covering direct and indirect attacks, the discovered concepts reveal a reusable vulnerability core across models and agents. A frozen VCG requires no further search and outperforms the strongest frozen discovery baseline by 14.2 percentage points under the same single-shot protocol, while transferring across scenarios and attack channels. The resulting VCG provides an auditable artifact for production safety teams to inspect vulnerabilities, validate patches, and accumulate reusable safety knowledge. Our code is available at https://github.com/henrymao2004/Auto-research-red-teaming-in-sleep.",Xutao Mao; Xiang Zheng; Cong Wang,2026-07-13,2026,arXiv,arXiv,,,cs.CR,arxiv-api,,,,,,,2607.11698,2026-07-17T17:58:18+00:00 ale-0323,Securing Unattended Loops,securing-unattended-loops,Paper,πŸ“„,"Temporary Authority, Permanent Effects: Commit-Time Authorization for LLM Agents",https://arxiv.org/abs/2607.10487,external,arxiv.org,"Proposes binding an agent's authority to the moment of commit rather than the moment of request, so a permission granted mid-run cannot be replayed later to cause irreversible effects in unattended execution.","Proposes binding an agent's authority to the moment of commit rather than the moment of request, so a permission granted mid-run cannot be replayed later to cause irreversible effects in unattended execution.","Proposes binding an agent's authority to the moment of commit rather than the moment of request, so a permission granted mid-run cannot be replayed later to cause irreversible effects in unattended execution.","Frames security as a recurring-loop boundary rather than a one-time prompt hygiene issue. Proposes binding an agent's authority to the moment of commit rather than the moment of request, so a permission granted mid-run cannot be replayed later to cause irreversible effects in unattended execution.","Use Temporary Authority, Permanent Effects: Commit-Time Authorization for LLM Agents to bound risk before recurring or unattended execution.",Research source arXiv:2607.10487; inspect its method and evaluation before treating results as production evidence.,medium,README.md,933,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L933,2026-07-15,Govern,govern,"Bound permissions, cost, failure, and escalation.",workspace,researcher;evaluator;operator;security,research-preprint,ok,https://arxiv.org/abs/2607.10487,"[2607.10487] Temporary Authority, Permanent Effects: Commit-Time Authorization for LLM Agents","LLM agents can commit durable effects from authority evidence that was valid earlier in execution: a DOM snapshot, approval epoch, version witness, branch token, or worker result. We study the commit boundary at which earlier authority evidence no longer authorizes a durable effect. We call this property commit-time authorization: a durable effect is authorized only if the witness that licensed its derived state remains fresh, causally prior, bound to the same effect, and eligible at commit time. We build a controlled-invalidation suite spanning browser, tool/API, and multi-agent workflows. The suite preserves the user goal and payload shape while invalidating the authority relation before durability. In the primary 54-task matrix, endpoint success remains high: 262/270 runs reach the visible result. Only 55/270 are authorized completions; among the 216 invalidating rows, 207 commit after the authorizing path has failed. All 54 clean controls remain authorized, and a separate 54-run authority-preserving check produces no unauthorized commits. We then evaluate mitigation families. Prompt caution and single-condition checks are insufficient because different hazards break different boundary conditions. Defenses work when they refresh, rebind, replan, or refuse at the durability boundary. CommitGuard, a fail-closed boundary monitor, blocks stale durable-effect attempts on protected commit surfaces when runtimes emit witness, dependency, binding, and eligibility signals. The result is a reporting and runtime-design lesson: endpoint success is a utility metric; authorized commit is a security property.",Igor Santos-Grueiro,2026-07-11,2026,arXiv,arXiv,,20 pages,cs.CR,arxiv-api,,,,,,,2607.10487,2026-07-17T17:58:18+00:00 -ale-0324,Securing Unattended Loops,securing-unattended-loops,Paper,πŸ“„,ANCHOR: Automated Alignment Auditing for CLI Agents on Real-World Harm,https://arxiv.org/abs/2607.10455,external,arxiv.org,"Automated auditing framework that probes CLI coding agents for real-world harmful behavior and grades alignment, giving unattended-agent operators a repeatable safety check rather than manual spot review.","Automated auditing framework that probes CLI coding agents for real-world harmful behavior and grades alignment, giving unattended-agent operators a repeatable safety check rather than manual spot review.","Automated auditing framework that probes CLI coding agents for real-world harmful behavior and grades alignment, giving unattended-agent operators a repeatable safety check rather than manual spot review.","Frames security as a recurring-loop boundary rather than a one-time prompt hygiene issue. Automated auditing framework that probes CLI coding agents for real-world harmful behavior and grades alignment, giving unattended-agent operators a repeatable safety check rather than manual spot review.",Use ANCHOR: Automated Alignment Auditing for CLI Agents on Real-World Harm to bound risk before recurring or unattended execution.,Research source arXiv:2607.10455; inspect its method and evaluation before treating results as production evidence.,medium,README.md,934,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L934,2026-07-15,Govern,govern,"Bound permissions, cost, failure, and escalation.",workspace;budget;escalation,researcher;evaluator;operator;security,research-preprint,ok,https://arxiv.org/abs/2607.10455,[2607.10455] ANCHOR: Automated Alignment Auditing for CLI Agents on Real-World Harm,"Autonomous CLI agents can now execute hundreds of actions across multi-hour sessions: writing code, executing shell commands, browsing the web, and managing cloud infrastructure, all with minimal human oversight. Does greater autonomy invite greater risk? We introduce ANCHOR, an automated auditing framework that stress-tests CLI agents on illegal tasks grounded in public US court cases. ANCHOR deploys an auditor agent fine-tuned on dark personality data using supervised and reinforcement fine tuning. This auditor roleplays persistent malicious users who decompose tasks, reframe requests upon refusal, and adapt strategies across multi-turn interactions. Evaluating frontier CLI agents, we find that while they often refuse illegal tasks when prompted directly, compliance reaches 100\% under persistent malicious interaction. When agents comply, they frequently exceed user requests, autonomously building infrastructure for large-scale harm, including catastrophic risk scenarios such as large-scale financial fraud and bioweapon development. These findings demonstrate that current alignment techniques are insufficient for autonomous agents and underscore the need for safety evaluations against persistent, adaptive malicious users. We release ANCHOR at https://github.com/garified/anchor",Kefan Song; Yanjun Qi,2026-07-11,2026,"International Conference on Machine Learning, 2026",arXiv,,"Accepted at ICML 2026. 19 pages, 14 figures, 5 tables",cs.AI,arxiv-api,,,,,,,2607.10455,2026-07-17T17:58:18+00:00 +ale-0324,Securing Unattended Loops,securing-unattended-loops,Paper,πŸ“„,ANCHOR: Automated Alignment Auditing for CLI Agents on Real-World Harm,https://arxiv.org/abs/2607.10455,external,arxiv.org,"Automated auditing framework that probes CLI coding agents for real-world harmful behavior and grades alignment, giving unattended-agent operators a repeatable safety check rather than manual spot review.","Automated auditing framework that probes CLI coding agents for real-world harmful behavior and grades alignment, giving unattended-agent operators a repeatable safety check rather than manual spot review.","Automated auditing framework that probes CLI coding agents for real-world harmful behavior and grades alignment, giving unattended-agent operators a repeatable safety check rather than manual spot review.","Frames security as a recurring-loop boundary rather than a one-time prompt hygiene issue. Automated auditing framework that probes CLI coding agents for real-world harmful behavior and grades alignment, giving unattended-agent operators a repeatable safety check rather than manual spot review.",Use ANCHOR: Automated Alignment Auditing for CLI Agents on Real-World Harm to bound risk before recurring or unattended execution.,Research source arXiv:2607.10455; inspect its method and evaluation before treating results as production evidence.,medium,README.md,934,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L934,2026-07-15,Govern,govern,"Bound permissions, cost, failure, and escalation.",workspace;budget;escalation,researcher;evaluator;operator;security,research-paper,ok,https://openreview.net/forum?id=YqTodSrPPB,[2607.10455] ANCHOR: Automated Alignment Auditing for CLI Agents on Real-World Harm,"Autonomous CLI agents can now execute hundreds of actions across multi-hour sessions: writing code, executing shell commands, browsing the web, and managing cloud infrastructure, all with minimal human oversight. Does greater autonomy invite greater risk? We introduce ANCHOR, an automated auditing framework that stress-tests CLI agents on illegal tasks grounded in public US court cases. ANCHOR deploys an auditor agent fine-tuned on dark personality data using supervised and reinforcement fine tuning. This auditor roleplays persistent malicious users who decompose tasks, reframe requests upon refusal, and adapt strategies across multi-turn interactions. Evaluating frontier CLI agents, we find that while they often refuse illegal tasks when prompted directly, compliance reaches 100\% under persistent malicious interaction. When agents comply, they frequently exceed user requests, autonomously building infrastructure for large-scale harm, including catastrophic risk scenarios such as large-scale financial fraud and bioweapon development. These findings demonstrate that current alignment techniques are insufficient for autonomous agents and underscore the need for safety evaluations against persistent, adaptive malicious users. We release ANCHOR at https://github.com/garified/anchor",Kefan Song; Yanjun Qi,2026-04-30,2026,Proceedings of the 43rd International Conference on Machine Learning (ICML),PMLR,,Accepted at Proceedings of the 43rd International Conference on Machine Learning (ICML); the linked arXiv record is the available paper version.,cs.AI,ICML OpenReview record,,,,,,,2607.10455,2026-07-17T17:58:18+00:00 ale-0325,Securing Unattended Loops,securing-unattended-loops,Tool,🧰,Clawk,https://github.com/clawkwork/clawk,external,github.com,"Runs coding agents inside disposable, network-restricted Linux VMs so an unattended or untrusted agent's blast radius is confined to a throwaway sandbox.","Runs coding agents inside disposable, network-restricted Linux VMs so an unattended or untrusted agent's blast radius is confined to a throwaway sandbox.","Runs coding agents inside disposable, network-restricted Linux VMs so an unattended or untrusted agent's blast radius is confined to a throwaway sandbox.","Execution isolation and permission boundaries are part of the design. Runs coding agents inside disposable, network-restricted Linux VMs so an unattended or untrusted agent's blast radius is confined to a throwaway sandbox.",Use Clawk to bound risk before recurring or unattended execution.,"Inspectable GitHub source (685 stars; 20 forks; Apache-2.0 license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,935,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L935,2026-07-15,Govern,govern,"Bound permissions, cost, failure, and escalation.",workspace,builder;operator;security,source-implementation,ok,https://github.com/clawkwork/clawk,"GitHub - clawkwork/clawk: Give coding agents a disposable Linux VM, not your laptop Β· GitHub","Give coding agents a disposable Linux VM, not your laptop - clawkwork/clawk",,2026-07-06,2026,clawkwork/clawk,GitHub,,,,github-api,clawkwork/clawk,685,20,Apache-2.0,2026-07-06T21:30:38Z,2026-07-17T17:32:14Z,,2026-07-17T17:58:18+00:00 ale-0326,Securing Unattended Loops,securing-unattended-loops,Blog,πŸ“,Auto-Review of Agent Actions Without Synchronous Human Oversight,https://alignment.openai.com/auto-review/,external,alignment.openai.com,"OpenAI's alignment team on reviewing agent actions asynchronously with automated reviewers when a human cannot watch every step, so oversight scales with agent throughput instead of gating it.","OpenAI's alignment team on reviewing agent actions asynchronously with automated reviewers when a human cannot watch every step, so oversight scales with agent throughput instead of gating it.","OpenAI's alignment team on reviewing agent actions asynchronously with automated reviewers when a human cannot watch every step, so oversight scales with agent throughput instead of gating it.","Frames security as a recurring-loop boundary rather than a one-time prompt hygiene issue. OpenAI's alignment team on reviewing agent actions asynchronously with automated reviewers when a human cannot watch every step, so oversight scales with agent throughput instead of gating it.",Use Auto-Review of Agent Actions Without Synchronous Human Oversight to bound risk before recurring or unattended execution.,"Contextual source from alignment.openai.com; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,936,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L936,2026-07-15,Govern,govern,"Bound permissions, cost, failure, and escalation.",escalation,operator;security,practitioner-analysis,ok,https://alignment.openai.com/auto-review/,"Auto-review of agent actions without synchronous human oversight Illustrative deployment snapshot showing 10,000 actions, most inside the sandbox, and out-of-sandbox actions reviewed by Auto-review.","Auto-review offers a safer default for deploying coding agents, using a separate agent to approve or deny boundary-crossing actions.",Maja TrΔ™bacz; Sam Arnesen; Ollie Matthews; Dylan Hurd; Won Park; Owen Lin; Joe Gershenson,2026-04-30,2026,OpenAI,OpenAI,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0327,Securing Unattended Loops,securing-unattended-loops,Paper,πŸ“„,SAFETY SENTRY: Context-Aware Human Intervention via EXECUTE-ASK-REFUSE Routing,https://arxiv.org/abs/2607.13594,external,arxiv.org,"Routes each proposed action among execute, ask a human, and refuse, with one threshold controlling the deployment's risk posture; experiments report stronger overall accuracy and safety recall than the compared baselines.","Routes each proposed action among execute, ask a human, and refuse, with one threshold controlling the deployment's risk posture; experiments report stronger overall accuracy and safety recall than the compared baselines.","Routes each proposed action among execute, ask a human, and refuse, with one threshold controlling the deployment's risk posture; experiments report stronger overall accuracy and safety recall than the compared baselines.","Context is managed as durable loop state rather than a single prompt payload. Routes each proposed action among execute, ask a human, and refuse, with one threshold controlling the deployment's risk posture; experiments report stronger overall accuracy and safety recall than the compared baselines.",Use SAFETY SENTRY: Context-Aware Human Intervention via EXECUTE-ASK-REFUSE Routing to bound risk before recurring or unattended execution.,Research source arXiv:2607.13594; inspect its method and evaluation before treating results as production evidence.,medium,README.md,937,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L937,2026-07-17,Govern,govern,"Bound permissions, cost, failure, and escalation.",context;escalation,researcher;evaluator;operator;security,research-preprint,ok,https://arxiv.org/abs/2607.13594,[2607.13594] SAFETY SENTRY: Context-Aware Human Intervention via EXECUTE-ASK-REFUSE Routing,"LLM agents act on real-world environments through tool calls, and a single misjudged action can cause irreversible harm. The standard safeguard is a guard model that labels each proposed action as safe or unsafe, but this binary view conflates two distinct decisions: whether the action is harmful in itself, and whether it is appropriate given the user's context. It also operates at the granularity of action categories rather than individual instances, producing routine interruptions that erode autonomy and train users to wave through the most consequential alerts. We reframe the problem as a per-instance three-way routing decision over {EXECUTE, ASK, REFUSE} and instantiate it with Safety Sentry, a lightweight guard model whose inference reduces to a single decoding call. A single decoding-time threshold lets one fixed checkpoint be re-positioned across deployments of differing risk tolerance without retraining. Safety Sentry outperforms a broad set of open-weight and frontier closed-source baselines on overall accuracy and safety-related recall, while controlling both directional error rates simultaneously.",Tianyu Chen; Chujia Hu; Wenjie Wang,2026-07-15,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2607.13594,2026-07-17T17:58:18+00:00 @@ -343,7 +343,7 @@ ale-0341,"State, Memory, And Context Persistence",state-memory-and-context-persi ale-0342,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Tool,🧰,Zep,https://github.com/getzep/zep,external,github.com,Temporal knowledge graph memory that tracks how facts about users and systems change across sessions.,Temporal knowledge graph memory that tracks how facts about users and systems change across sessions.,Temporal knowledge graph memory that tracks how facts about users and systems change across sessions.,Control flow is represented as an inspectable graph rather than an opaque prompt loop. Temporal knowledge graph memory that tracks how facts about users and systems change across sessions.,"Use Zep to carry context, state, and receipts across runs and failures.","Inspectable GitHub source (4,762 stars; 641 forks; Apache-2.0 license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,959,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L959,,Persist,persist,"Carry context, state, and receipts across runs.",context,builder,source-implementation,ok,https://github.com/getzep/zep,"GitHub - getzep/zep: Zep | Examples, Integrations, & More Β· GitHub","Zep | Examples, Integrations, & More. Contribute to getzep/zep development by creating an account on GitHub.",,2023-04-29,2023,getzep/zep,GitHub,,,,github-api,getzep/zep,4762,641,Apache-2.0,2023-04-29T14:06:22Z,2026-07-17T17:55:45Z,,2026-07-17T17:58:18+00:00 ale-0343,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Tool,🧰,LangMem,https://github.com/langchain-ai/langmem,external,github.com,"SDK for extracting, consolidating, and retrieving long-term agent memory between loop runs.","SDK for extracting, consolidating, and retrieving long-term agent memory between loop runs.","SDK for extracting, consolidating, and retrieving long-term agent memory between loop runs.","Persistent memory is treated as an external runtime artifact. SDK for extracting, consolidating, and retrieving long-term agent memory between loop runs.","Use LangMem to carry context, state, and receipts across runs and failures.","Inspectable GitHub source (1,566 stars; 177 forks; MIT license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,960,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L960,,Persist,persist,"Carry context, state, and receipts across runs.",context,builder,source-implementation,ok,https://github.com/langchain-ai/langmem,GitHub - langchain-ai/langmem Β· GitHub,Contribute to langchain-ai/langmem development by creating an account on GitHub.,,2025-01-21,2025,langchain-ai/langmem,GitHub,,,,github-api,langchain-ai/langmem,1566,177,MIT,2025-01-21T20:06:59Z,2026-07-17T07:50:42Z,,2026-07-17T17:58:18+00:00 ale-0344,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Tool,🧰,Beads,https://github.com/steveyegge/beads,external,github.com,"Git-plus-SQLite issue and memory store that agents read and write with a `bd` CLI, giving recurring loops durable task state and progress that survives context resets.","Git-plus-SQLite issue and memory store that agents read and write with a `bd` CLI, giving recurring loops durable task state and progress that survives context resets.","Git-plus-SQLite issue and memory store that agents read and write with a `bd` CLI, giving recurring loops durable task state and progress that survives context resets.","Durable execution and replay are treated as first-class loop infrastructure. Git-plus-SQLite issue and memory store that agents read and write with a `bd` CLI, giving recurring loops durable task state and progress that survives context resets.","Use Beads to carry context, state, and receipts across runs and failures.","Inspectable GitHub source (25,390 stars; 1,703 forks; MIT license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,961,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L961,,Persist,persist,"Carry context, state, and receipts across runs.",intake;context;state,builder,source-implementation,ok,https://github.com/gastownhall/beads,GitHub - gastownhall/beads: Beads - A memory upgrade for your coding agent Β· GitHub,Beads - A memory upgrade for your coding agent. Contribute to gastownhall/beads development by creating an account on GitHub.,,2025-10-12,2025,steveyegge/beads,GitHub,,,,github-api,steveyegge/beads,25390,1703,MIT,2025-10-12T03:09:46Z,2026-07-17T17:12:49Z,,2026-07-17T17:58:18+00:00 -ale-0345,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Paper,πŸ“„,ARC: Active and Reflection-driven Context Management for Long-Horizon Agents,https://arxiv.org/abs/2601.12030,external,arxiv.org,"Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.","Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.","Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.","Context is managed as durable loop state rather than a single prompt payload. Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.","Use ARC: Active and Reflection-driven Context Management for Long-Horizon Agents to carry context, state, and receipts across runs and failures.",Research source arXiv:2601.12030; inspect its method and evaluation before treating results as production evidence.,medium,README.md,962,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L962,,Persist,persist,"Carry context, state, and receipts across runs.",context,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2601.12030,[2601.12030] ARC: Active and Reflection-driven Context Management for Long-Horizon Information Seeking Agents,"Large language models are increasingly deployed as research agents for deep search and long-horizon information seeking, yet their performance often degrades as interaction histories grow. This degradation, known as context rot, reflects a failure to maintain coherent and task-relevant internal states over extended reasoning horizons. Existing approaches primarily manage context through raw accumulation or passive summarization, treating it as a static artifact and allowing early errors or misplaced emphasis to persist. Motivated by this perspective, we propose ARC, which is the first framework to systematically formulate context management as an active, reflection-driven process that treats context as a dynamic internal reasoning state during execution. ARC operationalizes this view through reflection-driven monitoring and revision, allowing agents to actively reorganize their working context when misalignment or degradation is detected. Experiments on challenging long-horizon information-seeking benchmarks show that ARC consistently outperforms passive context compression methods, achieving up to an 11% absolute improvement in accuracy on BrowseComp-ZH with Qwen2.5-32B-Instruct.",Yilun Yao; Shan Huang; Elsie Dai; Zhewen Tan; Zhenyu Duan; Shousheng Jia; Yanbing Jiang; Tong Yang,2026-01-17,2026,arXiv,arXiv,,"15 pages, 5 figures",cs.AI,arxiv-api,,,,,,,2601.12030,2026-07-17T17:58:18+00:00 +ale-0345,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Paper,πŸ“„,ARC: Active and Reflection-driven Context Management for Long-Horizon Agents,https://arxiv.org/abs/2601.12030,external,arxiv.org,"Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.","Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.","Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.","Context is managed as durable loop state rather than a single prompt payload. Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.","Use ARC: Active and Reflection-driven Context Management for Long-Horizon Agents to carry context, state, and receipts across runs and failures.",Research source arXiv:2601.12030; inspect its method and evaluation before treating results as production evidence.,medium,README.md,962,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L962,,Persist,persist,"Carry context, state, and receipts across runs.",context,researcher;evaluator,research-paper,ok,https://aclanthology.org/2026.findings-acl.930/,[2601.12030] ARC: Active and Reflection-driven Context Management for Long-Horizon Information Seeking Agents,"Large language models are increasingly deployed as research agents for deep search and long-horizon information seeking, yet their performance often degrades as interaction histories grow. This degradation, known as context rot, reflects a failure to maintain coherent and task-relevant internal states over extended reasoning horizons. Existing approaches primarily manage context through raw accumulation or passive summarization, treating it as a static artifact and allowing early errors or misplaced emphasis to persist. Motivated by this perspective, we propose ARC, which is the first framework to systematically formulate context management as an active, reflection-driven process that treats context as a dynamic internal reasoning state during execution. ARC operationalizes this view through reflection-driven monitoring and revision, allowing agents to actively reorganize their working context when misalignment or degradation is detected. Experiments on challenging long-horizon information-seeking benchmarks show that ARC consistently outperforms passive context compression methods, achieving up to an 11% absolute improvement in accuracy on BrowseComp-ZH with Qwen2.5-32B-Instruct.",Yilun Yao; Shan Huang; Elsie Dai; Zhewen Tan; Zhenyu Duan; Shousheng Jia; Yanbing Jiang; Tong Yang,2026,2026,Findings of the Association for Computational Linguistics: ACL,Association for Computational Linguistics,10.18653/v1/2026.findings-acl.930,Published in Findings of the Association for Computational Linguistics: ACL; the linked arXiv record remains available for open access.,cs.AI,ACL Anthology and DOI records,,,,,,,2601.12030,2026-07-17T17:58:18+00:00 ale-0346,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Paper,πŸ“„,"Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers",https://arxiv.org/abs/2603.07670,external,arxiv.org,"Formalizes agent memory as a write-manage-read loop and surveys compression, retrieval, reflective self-improvement, and policy-learned management across recurring runs.","Formalizes agent memory as a write-manage-read loop and surveys compression, retrieval, reflective self-improvement, and policy-learned management across recurring runs.","Formalizes agent memory as a write-manage-read loop and surveys compression, retrieval, reflective self-improvement, and policy-learned management across recurring runs.","Evaluation data is used as the feedback signal for improving loop behavior. Formalizes agent memory as a write-manage-read loop and surveys compression, retrieval, reflective self-improvement, and policy-learned management across recurring runs.","Use Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers to carry context, state, and receipts across runs and failures.",Research source arXiv:2603.07670; inspect its method and evaluation before treating results as production evidence.,medium,README.md,963,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L963,,Persist,persist,"Carry context, state, and receipts across runs.",context;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2603.07670,"[2603.07670] Memory for Autonomous LLM Agents:Mechanisms, Evaluation, and Emerging Frontiers","Large language model (LLM) agents increasingly operate in settings where a single context window is far too small to capture what has happened, what was learned, and what should not be repeated. Memory -- the ability to persist, organize, and selectively recall information across interactions -- is what turns a stateless text generator into a genuinely adaptive agent. This survey offers a structured account of how memory is designed, implemented, and evaluated in modern LLM-based agents, covering work from 2022 through early 2026. We formalize agent memory as a \emph{write--manage--read} loop tightly coupled with perception and action, then introduce a three-dimensional taxonomy spanning temporal scope, representational substrate, and control policy. Five mechanism families are examined in depth: context-resident compression, retrieval-augmented stores, reflective self-improvement, hierarchical virtual context, and policy-learned management. On the evaluation side, we trace the shift from static recall benchmarks to multi-session agentic tests that interleave memory with decision-making, analyzing four recent benchmarks that expose stubborn gaps in current systems. We also survey applications where memory is the differentiating factor -- personal assistants, coding agents, open-world games, scientific reasoning, and multi-agent teamwork -- and address the engineering realities of write-path filtering, contradiction handling, latency budgets, and privacy governance. The paper closes with open challenges: continual consolidation, causally grounded retrieval, trustworthy reflection, learned forgetting, and multimodal embodied memory.",Pengfei Du,2026-03-08,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2603.07670,2026-07-17T17:58:18+00:00 ale-0347,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Paper,πŸ“„,"Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering",https://arxiv.org/abs/2604.08224,external,arxiv.org,"Reviews how durable state, reusable skills, protocols, and the harness move out of model weights into external infrastructure, the substrate that lets loops persist progress and reuse capability across runs.","Reviews how durable state, reusable skills, protocols, and the harness move out of model weights into external infrastructure, the substrate that lets loops persist progress and reuse capability across runs.","Reviews how durable state, reusable skills, protocols, and the harness move out of model weights into external infrastructure, the substrate that lets loops persist progress and reuse capability across runs.","Durable execution and replay are treated as first-class loop infrastructure. Reviews how durable state, reusable skills, protocols, and the harness move out of model weights into external infrastructure, the substrate that lets loops persist progress and reuse capability across runs.","Use Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering to carry context, state, and receipts across runs and failures.",Research source arXiv:2604.08224; inspect its method and evaluation before treating results as production evidence.,medium,README.md,964,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L964,,Persist,persist,"Carry context, state, and receipts across runs.",context;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2604.08224,"[2604.08224] Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering","Large language model (LLM) agents are increasingly built less by changing model weights than by reorganizing the runtime around them. Capabilities that earlier systems expected the model to recover internally are now externalized into memory stores, reusable skills, interaction protocols, and the surrounding harness that makes these modules reliable in practice. This paper reviews that shift through the lens of externalization. Drawing on the idea of cognitive artifacts, we argue that agent infrastructure matters not merely because it adds auxiliary components, but because it transforms hard cognitive burdens into forms that the model can solve more reliably. Under this view, memory externalizes state across time, skills externalize procedural expertise, protocols externalize interaction structure, and harness engineering serves as the unification layer that coordinates them into governed execution. We trace a historical progression from weights to context to harness, analyze memory, skills, and protocols as three distinct but coupled forms of externalization, and examine how they interact inside a larger agent system. We further discuss the trade-off between parametric and externalized capability, identify emerging directions such as self-evolving harnesses and shared agent infrastructure, and discuss open challenges in evaluation, governance, and the long-term co-evolution of models and external infrastructure. The result is a systems-level framework for explaining why practical agent progress increasingly depends not only on stronger models, but on better external cognitive infrastructure.",Chenyu Zhou; Huacan Chai; Wenteng Chen; Zihan Guo; Rong Shan; Yuanyi Song; Tianyi Xu; Yingxuan Yang; Aofan Yu; Weiming Zhang; Congming Zheng; Jiachen Zhu; Zeyu Zheng; Zhuosheng Zhang; Xingyu Lou; Changwang Zhang; Zhihui Fu; Jun Wang; Weiwen Liu; Jianghao Lin; Weinan Zhang,2026-04-09,2026,arXiv,arXiv,,"54 pages, tech report on Externalization in LLM Agents",cs.SE,arxiv-api,,,,,,,2604.08224,2026-07-17T17:58:18+00:00 ale-0348,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Paper,πŸ“„,Meta Context Engineering via Agentic Skill Evolution,https://arxiv.org/abs/2601.21557,external,arxiv.org,"A bi-level loop where a meta-agent evolves reusable skills while a base-agent optimizes context, co-evolving the harness and context artifacts across runs (ICML 2026).","A bi-level loop where a meta-agent evolves reusable skills while a base-agent optimizes context, co-evolving the harness and context artifacts across runs (ICML 2026).","A bi-level loop where a meta-agent evolves reusable skills while a base-agent optimizes context, co-evolving the harness and context artifacts across runs (ICML 2026).","Context is managed as durable loop state rather than a single prompt payload. A bi-level loop where a meta-agent evolves reusable skills while a base-agent optimizes context, co-evolving the harness and context artifacts across runs (ICML 2026).","Use Meta Context Engineering via Agentic Skill Evolution to carry context, state, and receipts across runs and failures.",Research source arXiv:2601.21557; inspect its method and evaluation before treating results as production evidence.,medium,README.md,965,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L965,,Persist,persist,"Carry context, state, and receipts across runs.",context,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2601.21557,[2601.21557] Meta Context Engineering via Agentic Skill Evolution,"The operational efficacy of large language models relies heavily on their inference-time context. This has established Context Engineering (CE) as a formal discipline for optimizing these inputs. Current CE methods rely on manually crafted harnesses, such as rigid generation-reflection workflows and predefined context schemas. They impose structural biases and restrict context optimization to a narrow, intuition-bound design space. To address this, we introduce Meta Context Engineering (MCE), a bi-level framework that supersedes static CE heuristics by co-evolving CE skills and context artifacts. In MCE iterations, a meta-level agent refines engineering skills via agentic crossover, a deliberative search over the history of skills, their executions, and evaluations. A base-level agent executes these skills, learns from training rollouts, and optimizes context as flexible files and code. We evaluate MCE across five disparate domains under offline and online settings. MCE demonstrates consistent performance gains, achieving 5.6--53.8% relative improvement over state-of-the-art agentic CE methods (mean of 16.9%), while maintaining superior context adaptability, transferability, and efficiency in both context usage and training.",Haoran Ye; Xuning He; Vincent Arak; Haonan Dong; Guojie Song,2026-01-29,2026,arXiv,arXiv,,"46 pages, 4 figures",cs.AI,arxiv-api,,,,,,,2601.21557,2026-07-17T17:58:18+00:00 @@ -365,7 +365,7 @@ ale-0363,"State, Memory, And Context Persistence",state-memory-and-context-persi ale-0364,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Paper,πŸ“„,SkillCenter: A Large-Scale Source-Grounded Skill Library for Autonomous AI Agents,https://arxiv.org/abs/2607.07676,external,arxiv.org,"Claims the largest open skill library for agents (216,938 structured skills across 24 domain bundles), built with an LLM quality gate (SkillGate) and iterative source-grounding that maps each retained claim to an exact source quotation, and shipped as offline-searchable SQLite FTS5 bundles, infrastructure for skills-as-persistent-state that agent loops accumulate and reuse.","Claims the largest open skill library for agents (216,938 structured skills across 24 domain bundles), built with an LLM quality gate (SkillGate) and iterative source-grounding that maps each retained claim to an exact source quotation, and shipped as offline-searchable SQLite FTS5 bundles, infrastructure for skills-as-persistent-state that agent loops accumulate and reuse.","Claims the largest open skill library for agents (216,938 structured skills across 24 domain bundles), built with an LLM quality gate (SkillGate) and iterative source-grounding that maps each retained claim to an exact source quotation, and shipped as offline-searchable SQLite FTS5 bundles, infrastructure for skills-as-persistent-state that agent loops accumulate and reuse.","State persistence is explicit enough for repeated runs and handoff. Claims the largest open skill library for agents (216,938 structured skills across 24 domain bundles), built with an LLM quality gate (SkillGate) and iterative source-grounding that maps each retained claim to an exact source quotation, and shipped as offline-searchable SQLite FTS5 bundles, infrastructure for skills-as-persistent-state that agent loops accumulate and reuse.","Use SkillCenter: A Large-Scale Source-Grounded Skill Library for Autonomous AI Agents to carry context, state, and receipts across runs and failures.",Research source arXiv:2607.07676; inspect its method and evaluation before treating results as production evidence.,medium,README.md,981,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L981,,Persist,persist,"Carry context, state, and receipts across runs.",state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.07676,[2607.07676] SkillCenter: A Large-Scale Source-Grounded Skill Library for Autonomous AI Agents,"Autonomous AI agents can execute complex tasks with limited human review, yet they often lack the grounded operational knowledge to make their outputs not just executable but correct, secure, and maintainable. We introduce SkillCenter, to our knowledge the largest open skill library for agents by total count: 216,938 structured skills across 24 domain bundles. A SkillGate-filtered pipeline contributes 114,565 source-grounded skills from peer-reviewed journals, ArXiv, and over 24,000 technical sources, integrated with 102,373 community skills from GitHub and the ClawHub marketplace. We present the end-to-end framework that builds the pipeline subset: multi-source acquisition, an LLM-based quality gate (SkillGate), template-driven generation, iterative source-grounding, and quality-controlled publishing. Source grounding is a traceability guarantee: each retained claim maps to an exact quotation in its source. All skills ship as offline-searchable SQLite FTS5 bundles.",Tianming Sha; Yue Zhao; Lichao Sun; Yushun Dong,2026-07-08,2026,arXiv,arXiv,,"44 pages, 5 figures. Code: https://github.com/LabRAI/SkillCenter ; Data: https://huggingface.co/datasets/Tommysha/skillcenter-bundles",cs.AI,arxiv-api,,,,,,,2607.07676,2026-07-17T17:58:18+00:00 ale-0365,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Blog,πŸ“,How version control will evolve for the agent boom,https://entire.io/blog/how-version-control-will-evolve-for-the-agent-boom,external,entire.io,"Thomas Dohmke (former GitHub CEO, now founder of Entire) argues that agent session logs (prompts, tool calls, and decision checkpoints) are becoming the most important artifact in software development and should be versioned alongside code so agent fleets stop repeating mistakes, and that Git hosting must re-decentralize for agent-scale parallelism.","Thomas Dohmke (former GitHub CEO, now founder of Entire) argues that agent session logs (prompts, tool calls, and decision checkpoints) are becoming the most important artifact in software development and should be versioned alongside code so agent fleets stop repeating mistakes, and that Git hosting must re-decentralize for agent-scale parallelism.","Thomas Dohmke (former GitHub CEO, now founder of Entire) argues that agent session logs (prompts, tool calls, and decision checkpoints) are becoming the most important artifact in software development and should be versioned alongside code so agent fleets stop repeating mistakes, and that Git hosting must re-decentralize for agent-scale parallelism.","Checkpointed state makes long-running agent work recoverable across failures. Thomas Dohmke (former GitHub CEO, now founder of Entire) argues that agent session logs (prompts, tool calls, and decision checkpoints) are becoming the most important artifact in software development and should be versioned alongside code so agent fleets stop repeating mistakes, and that Git hosting must re-decentralize for agent-scale parallelism.","Use How version control will evolve for the agent boom to carry context, state, and receipts across runs and failures.","Contextual source from entire.io; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,982,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L982,,Persist,persist,"Carry context, state, and receipts across runs.",workspace;state;exit,builder,practitioner-analysis,ok,https://entire.io/blog/how-version-control-will-evolve-for-the-agent-boom,How Version Control Will Evolve for the Agent Boom Β· Entire,"To meet the demand of the agent boom, Git hosting must return to its original promise: a distributed network of many hosts.",,2026-07-06,2026,,Entire,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0366,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Tool,🧰,self-learning-skills,https://github.com/Kulaxyz/self-learning-skills,external,github.com,"Meta-skill for Claude Code, Cursor, and AGENTS.md-compatible agents that recognizes when a session has earned a hard-won golden path (or hit a dead-end worth remembering), distills the procedure including failed approaches, and persists it as a skill or rule auto-loaded next run, turning each session's discoveries into durable cross-session loop state.","Meta-skill for Claude Code, Cursor, and AGENTS.md-compatible agents that recognizes when a session has earned a hard-won golden path (or hit a dead-end worth remembering), distills the procedure including failed approaches, and persists it as a skill or rule auto-loaded next run, turning each session's discoveries into durable cross-session loop state.","Meta-skill for Claude Code, Cursor, and AGENTS.md-compatible agents that recognizes when a session has earned a hard-won golden path (or hit a dead-end worth remembering), distills the procedure including failed approaches, and persists it as a skill or rule auto-loaded next run, turning each session's discoveries into durable cross-session loop state.","Durable execution and replay are treated as first-class loop infrastructure. Meta-skill for Claude Code, Cursor, and AGENTS.md-compatible agents that recognizes when a session has earned a hard-won golden path (or hit a dead-end worth remembering), distills the procedure including failed approaches, and persists it as a skill or rule auto-loaded next run, turning each session's discoveries into durable cross-session loop state.","Use self-learning-skills to carry context, state, and receipts across runs and failures.","Inspectable GitHub source (883 stars; 36 forks; MIT license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,983,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L983,,Persist,persist,"Carry context, state, and receipts across runs.",state,builder,source-implementation,ok,https://github.com/Kulaxyz/self-learning-skills,"GitHub - Kulaxyz/self-learning-skills: A self-improving skill for AI coding agents (Claude Code, Cursor, AGENTS.md): recognize a hard-won golden path in a session and harvest it into a reusable skill/rule for next time. Β· GitHub","A self-improving skill for AI coding agents (Claude Code, Cursor, AGENTS.md): recognize a hard-won golden path in a session and harvest it into a reusable skill/rule for next time. - Kulaxyz/self-learning-skills",,2026-06-28,2026,Kulaxyz/self-learning-skills,GitHub,,,,github-api,Kulaxyz/self-learning-skills,883,36,MIT,2026-06-28T19:30:36Z,2026-07-17T17:53:19Z,,2026-07-17T17:58:18+00:00 -ale-0367,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Paper,πŸ“„,GitLake: Git-for-data for the agentic lakehouse,https://arxiv.org/abs/2607.08319,external,arxiv.org,"Git-for-data design for an agent-first lakehouse that lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, so agents work on isolated branches while humans review and publish, and pipeline outputs become visible atomically or not at all, with production lessons and correctness insights from a preliminary Alloy model of the core abstractions.","Git-for-data design for an agent-first lakehouse that lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, so agents work on isolated branches while humans review and publish, and pipeline outputs become visible atomically or not at all, with production lessons and correctness insights from a preliminary Alloy model of the core abstractions.","Git-for-data design for an agent-first lakehouse that lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, so agents work on isolated branches while humans review and publish, and pipeline outputs become visible atomically or not at all, with production lessons and correctness insights from a preliminary Alloy model of the core abstractions.","Makes persistence and context management visible as runtime design choices. Git-for-data design for an agent-first lakehouse that lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, so agents work on isolated branches while humans review and publish, and pipeline outputs become visible atomically or not at all, with production lessons and correctness insights from a preliminary Alloy model of the core abstractions.","Use GitLake: Git-for-data for the agentic lakehouse to carry context, state, and receipts across runs and failures.",Research source arXiv:2607.08319; inspect its method and evaluation before treating results as production evidence.,medium,README.md,984,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L984,,Persist,persist,"Carry context, state, and receipts across runs.",context;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.08319,[2607.08319] GitLake: Git-for-data for the agentic lakehouse,"We present GitLake, a Git-for-data design for an agent-first lakehouse. The system lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, letting agents work on isolated branches while humans review and publish changes. Pipelines run on temporary branches and publish through a final merge, so all outputs become visible atomically or none do. Finally, we report production lessons as well as correctness insights from a preliminary Alloy model of our core abstractions.",Weiming Sheng; Jinlang Wang; Manuel Barros; Aldrin Montana; Jacopo Tagliabue; Luca Bigon,2026-07-09,2026,arXiv,arXiv,,"Pre-print of the paper accepted at DASHSys, VLDB 2026, Boston, USA",cs.DB,arxiv-api,,,,,,,2607.08319,2026-07-17T17:58:18+00:00 +ale-0367,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Paper,πŸ“„,GitLake: Git-for-data for the agentic lakehouse,https://arxiv.org/abs/2607.08319,external,arxiv.org,"Git-for-data design for an agent-first lakehouse that lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, so agents work on isolated branches while humans review and publish, and pipeline outputs become visible atomically or not at all, with production lessons and correctness insights from a preliminary Alloy model of the core abstractions.","Git-for-data design for an agent-first lakehouse that lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, so agents work on isolated branches while humans review and publish, and pipeline outputs become visible atomically or not at all, with production lessons and correctness insights from a preliminary Alloy model of the core abstractions.","Git-for-data design for an agent-first lakehouse that lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, so agents work on isolated branches while humans review and publish, and pipeline outputs become visible atomically or not at all, with production lessons and correctness insights from a preliminary Alloy model of the core abstractions.","Makes persistence and context management visible as runtime design choices. Git-for-data design for an agent-first lakehouse that lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, so agents work on isolated branches while humans review and publish, and pipeline outputs become visible atomically or not at all, with production lessons and correctness insights from a preliminary Alloy model of the core abstractions.","Use GitLake: Git-for-data for the agentic lakehouse to carry context, state, and receipts across runs and failures.",Research source arXiv:2607.08319; inspect its method and evaluation before treating results as production evidence.,medium,README.md,984,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L984,,Persist,persist,"Carry context, state, and receipts across runs.",context;state,researcher;evaluator,research-paper,ok,https://arxiv.org/abs/2607.08319,[2607.08319] GitLake: Git-for-data for the agentic lakehouse,"We present GitLake, a Git-for-data design for an agent-first lakehouse. The system lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, letting agents work on isolated branches while humans review and publish changes. Pipelines run on temporary branches and publish through a final merge, so all outputs become visible atomically or none do. Finally, we report production lessons as well as correctness insights from a preliminary Alloy model of our core abstractions.",Weiming Sheng; Jinlang Wang; Manuel Barros; Aldrin Montana; Jacopo Tagliabue; Luca Bigon,2026,2026,DASHSys Workshop at the International Conference on Very Large Data Bases (VLDB),VLDB Endowment,,Accepted at DASHSys Workshop at the International Conference on Very Large Data Bases (VLDB); the linked arXiv record is the available paper version.,cs.DB,Current arXiv acceptance note and official workshop page,,,,,,,2607.08319,2026-07-17T17:58:18+00:00 ale-0368,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Paper,πŸ“„,Shared Selective Persistent Memory for Agentic LLM Systems,https://arxiv.org/abs/2607.09493,external,arxiv.org,"Architecture that selectively persists four categories of reusable context (task specifications, data schemas, tool configurations, output constraints) across agent sessions while discarding session-specific reasoning traces, with cross-user sharing under access controls and a zero-token refresh path for recurring data updates, reporting 96% task completion vs 79% without memory and 71% with full-history carryover.","Architecture that selectively persists four categories of reusable context (task specifications, data schemas, tool configurations, output constraints) across agent sessions while discarding session-specific reasoning traces, with cross-user sharing under access controls and a zero-token refresh path for recurring data updates, reporting 96% task completion vs 79% without memory and 71% with full-history carryover.","Architecture that selectively persists four categories of reusable context (task specifications, data schemas, tool configurations, output constraints) across agent sessions while discarding session-specific reasoning traces, with cross-user sharing under access controls and a zero-token refresh path for recurring data updates, reporting 96% task completion vs 79% without memory and 71% with full-history carryover.","Persistent memory is treated as an external runtime artifact. Architecture that selectively persists four categories of reusable context (task specifications, data schemas, tool configurations, output constraints) across agent sessions while discarding session-specific reasoning traces, with cross-user sharing under access controls and a zero-token refresh path for recurring data updates, reporting 96% task completion vs 79% without memory and 71% with full-history carryover.","Use Shared Selective Persistent Memory for Agentic LLM Systems to carry context, state, and receipts across runs and failures.",Research source arXiv:2607.09493; inspect its method and evaluation before treating results as production evidence.,medium,README.md,985,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L985,,Persist,persist,"Carry context, state, and receipts across runs.",workspace;context;state;budget;exit,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.09493,[2607.09493] Shared Selective Persistent Memory for Agentic LLM Systems,"Agentic LLM systems that generate code through multi-turn tool use face a fundamental context problem: each session starts from zero, discarding the configuration choices, domain constraints, data schemas, and tool-use patterns that made previous sessions productive. Naively persisting entire conversation histories is token-inefficient and counterproductive: irrelevant context degrades generation quality. We introduce shared selective persistent memory, an architecture that identifies and retains four categories of reusable context (task specifications, data schemas, tool configurations, and output constraints) while discarding session-specific reasoning traces. Crucially, this memory is shared: workspaces encapsulating selective memory can be transferred across users with role-based access control, enabling collaborative reuse without redundant specification. We implement it in a deployed collaborative workspace platform where LLM agents produce, edit, and maintain git-versioned artifacts (dashboards, reports, and data-driven documents) from heterogeneous sources (CSV, SQL, REST APIs, and MCP servers). A complementary zero-token data refresh mechanism decouples generated programs from runtime data, enabling artifact reuse without re-invocation. Across three enterprise scenarios, shared selective persistent memory achieves 96% task completion (vs. 79% without memory and 71% with full history). Zero-token refresh eliminates LLM re-invocation for recurring updates (14x task-time reduction), while summary-driven generation cuts per-invocation token cost by 97x versus raw data injection. A replication on four public datasets confirms generalizability, with zero-token refresh succeeding in 12/12 trials. Notably, naive full-history persistence actively degrades completion by biasing the agent with stale traces, while selective memory outperforms both extremes.",Sanjana Pedada; Aditya Dhavala; Neelraj Patil,2026-07-10,2026,arXiv,arXiv,,"11 pages, 2 figures, 4 tables",cs.AI,arxiv-api,,,,,,,2607.09493,2026-07-17T17:58:18+00:00 ale-0369,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Paper,πŸ“„,Scoped Verification for Reliable Long-Horizon Agentic Context Evolution,https://arxiv.org/abs/2607.09175,external,arxiv.org,"GRACE represents an agent's persistent instructions as a typed semantic graph and runs scoped verification over the local neighborhood of each proposed edit before committing it, so accumulated context evolves reliably across long-horizon deployment under distribution shift instead of drifting as flat text; evaluated on telecom agent tasks.","GRACE represents an agent's persistent instructions as a typed semantic graph and runs scoped verification over the local neighborhood of each proposed edit before committing it, so accumulated context evolves reliably across long-horizon deployment under distribution shift instead of drifting as flat text; evaluated on telecom agent tasks.","GRACE represents an agent's persistent instructions as a typed semantic graph and runs scoped verification over the local neighborhood of each proposed edit before committing it, so accumulated context evolves reliably across long-horizon deployment under distribution shift instead of drifting as flat text; evaluated on telecom agent tasks.","Control flow is represented as an inspectable graph rather than an opaque prompt loop. GRACE represents an agent's persistent instructions as a typed semantic graph and runs scoped verification over the local neighborhood of each proposed edit before committing it, so accumulated context evolves reliably across long-horizon deployment under distribution shift instead of drifting as flat text; evaluated on telecom agent tasks.","Use Scoped Verification for Reliable Long-Horizon Agentic Context Evolution to carry context, state, and receipts across runs and failures.",Research source arXiv:2607.09175; inspect its method and evaluation before treating results as production evidence.,medium,README.md,986,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L986,,Persist,persist,"Carry context, state, and receipts across runs.",context;verification;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2607.09175,[2607.09175] Scoped Verification for Reliable Long-Horizon Agentic Context Evolution under Distribution Shift,"Deployed LLM agents rely on agentic context, the model-external textual control content assembled by an operational harness. In this work, the mutable component of that context is a persistent system-level instruction that is updated from operational experience while the model, tools, and harness remain fixed. Over long evolution horizons, flat-text maintenance makes verification increasingly difficult as accumulated instructions grow and interact. We propose Graph-Regularized Agentic Context Evolution (GRACE), which maintains the persistent instruction component as a typed semantic graph and validates proposed updates within the local typed neighborhoods of modified nodes. Accepted graph updates are reconstructed as incremental edits to the textual instruction checkpoint used at deployment. We evaluate GRACE within a fixed telecom agent harness derived from $\tau^2$-bench under a controlled distribution-shift protocol. Across five independent replications, GRACE improves strict reliability, measured by pass^3, from the Gemini 2.5 Flash zero-shot value of 0.091 to 0.673$\pm$0.136 at the final checkpoint. This exceeds a Gemini 3.1 Pro zero-shot reference of 0.242 on the same held-out set, while the flat-text HCE baseline finishes at 0.191$\pm$0.051. These results identify two requirements for reliable long-horizon context evolution, a structural substrate that makes verification local and a consolidation mechanism that keeps accumulated instruction content usable.",Dan C. Hsu; Luke Lu,2026-07-10,2026,arXiv,arXiv,,"18 pages, 3 figs",cs.AI,arxiv-api,,,,,,,2607.09175,2026-07-17T17:58:18+00:00 ale-0370,"State, Memory, And Context Persistence",state-memory-and-context-persistence,Tool,🧰,AgentMemory,https://github.com/rohitg00/agentmemory,external,github.com,"Persistent cross-session memory for coding agents: auto-capture lifecycle hooks, an MCP server, and a REST API so progress, decisions, and context survive across runs and tools.","Persistent cross-session memory for coding agents: auto-capture lifecycle hooks, an MCP server, and a REST API so progress, decisions, and context survive across runs and tools.","Persistent cross-session memory for coding agents: auto-capture lifecycle hooks, an MCP server, and a REST API so progress, decisions, and context survive across runs and tools.","Persistent memory is treated as an external runtime artifact. Persistent cross-session memory for coding agents: auto-capture lifecycle hooks, an MCP server, and a REST API so progress, decisions, and context survive across runs and tools.","Use AgentMemory to carry context, state, and receipts across runs and failures.","Inspectable GitHub source (25,285 stars; 2,095 forks; Apache-2.0 license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,987,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L987,,Persist,persist,"Carry context, state, and receipts across runs.",workspace;context;state,builder,source-implementation,ok,https://github.com/rohitg00/agentmemory,GitHub - rohitg00/agentmemory: #1 Persistent memory for AI coding agents based on real-world benchmarks Β· GitHub,#1 Persistent memory for AI coding agents based on real-world benchmarks - rohitg00/agentmemory,,2026-02-25,2026,rohitg00/agentmemory,GitHub,,,,github-api,rohitg00/agentmemory,25285,2095,Apache-2.0,2026-02-25T07:32:52Z,2026-07-17T17:51:03Z,,2026-07-17T17:58:18+00:00 @@ -396,7 +396,7 @@ ale-0394,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent- ale-0395,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent-delegation,Tool,🧰,Omnigent,https://github.com/omnigent-ai/omnigent,external,github.com,"Databricks' open-source meta-harness and control plane that runs Claude Code, Codex, Cursor, and Pi under shared policies, with budget caps and human-approval gates enforced at the harness layer rather than in prompts.","Databricks' open-source meta-harness and control plane that runs Claude Code, Codex, Cursor, and Pi under shared policies, with budget caps and human-approval gates enforced at the harness layer rather than in prompts.","Databricks' open-source meta-harness and control plane that runs Claude Code, Codex, Cursor, and Pi under shared policies, with budget caps and human-approval gates enforced at the harness layer rather than in prompts.","Shows how delegation, handoff, and workflow control turn one agent into a coordinated loop. Databricks' open-source meta-harness and control plane that runs Claude Code, Codex, Cursor, and Pi under shared policies, with budget caps and human-approval gates enforced at the harness layer rather than in prompts.",Use Omnigent to choose an implementation surface for repeatable agent work.,"Inspectable GitHub source (7,417 stars; 1,055 forks; Apache-2.0 license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,1019,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1019,,Build,build,"Choose runtimes, tools, and delegation surfaces.",budget;escalation,builder,source-implementation,ok,https://github.com/omnigent-ai/omnigent,"GitHub - omnigent-ai/omnigent: Omnigent is an open-source AI agent framework and meta-harness: orchestrate Claude Code, Codex, Cursor, Pi, and custom agents β€” swap harnesses without rewriting, enforce policies and sandboxing, and collaborate in real time from any device. Β· GitHub","Omnigent is an open-source AI agent framework and meta-harness: orchestrate Claude Code, Codex, Cursor, Pi, and custom agents β€” swap harnesses without rewriting, enforce policies and sandboxing, and collaborate in real time from any device. - omnigent-ai/omnigent",,2026-06-11,2026,omnigent-ai/omnigent,GitHub,,,,github-api,omnigent-ai/omnigent,7417,1055,Apache-2.0,2026-06-11T12:18:13Z,2026-07-17T17:39:16Z,,2026-07-17T17:58:18+00:00 ale-0396,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent-delegation,Paper,πŸ“„,From Agent Loops to Structured Graphs: A Scheduler-Theoretic Framework for LLM Agent Execution,https://arxiv.org/abs/2604.11378,external,arxiv.org,"Replaces opaque agent loops with immutable plan-version DAGs and a planning-execution-recovery split, giving inspectable scheduling, deterministic recovery, escalation, and termination guarantees.","Replaces opaque agent loops with immutable plan-version DAGs and a planning-execution-recovery split, giving inspectable scheduling, deterministic recovery, escalation, and termination guarantees.","Replaces opaque agent loops with immutable plan-version DAGs and a planning-execution-recovery split, giving inspectable scheduling, deterministic recovery, escalation, and termination guarantees.","Control flow is represented as an inspectable graph rather than an opaque prompt loop. Replaces opaque agent loops with immutable plan-version DAGs and a planning-execution-recovery split, giving inspectable scheduling, deterministic recovery, escalation, and termination guarantees.",Use From Agent Loops to Structured Graphs: A Scheduler-Theoretic Framework for LLM Agent Execution to choose an implementation surface for repeatable agent work.,Research source arXiv:2604.11378; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1020,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1020,,Build,build,"Choose runtimes, tools, and delegation surfaces.",trigger;escalation;exit,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2604.11378,[2604.11378] From Agent Loops to Structured Graphs:A Scheduler-Theoretic Framework for LLM Agent Execution,"The dominant paradigm for building LLM based agents is the Agent Loop, an iterative cycle where a single language model decides what to do next by reading an ever growing context window. This paradigm has three structural weaknesses: implicit dependencies between steps, unbounded recovery loops, and mutable execution history that complicates debugging. We characterize the Agent Loop as a single ready unit scheduler: at any moment, at most one executable unit is active, and the choice of which unit to activate comes from opaque LLM inference rather than an inspectable policy. This perspective places Agent Loops and graph based execution engines on a single semantic continuum. We propose SGH, Structured Graph Harness, which lifts control flow from implicit context into an explicit static DAG. SGH makes three commitments: execution plans are immutable within a plan version, planning execution and recovery are separated into three layers, and recovery follows a strict escalation protocol. These choices trade some expressiveness for controllability, verifiability, and implementability. Our contributions are fourfold: a scheduler unified framework that applies classical scheduling theory to LLM agent execution and identifies challenges introduced by non deterministic LLM nodes; a trade off analysis of controllability, expressiveness, and implementability across 70 surveyed systems; a formal specification including a node state machine with termination and soundness guarantees; and an attributable experimental framework with a seven group design for future validation. This is a position paper and design proposal. We provide a theoretical framework, design analysis, and experimental protocol, not a production implementation or empirical results.",Hu Wei,2026-04-13,2026,arXiv,arXiv,,"51 pages, 4 figures",cs.AI,arxiv-api,,,,,,,2604.11378,2026-07-17T17:58:18+00:00 ale-0397,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent-delegation,Tool,🧰,Eve,https://github.com/vercel/eve,external,github.com,"Vercel's TypeScript-native agent framework with durable execution, sandboxed compute, and OpenTelemetry tracing built in, so recurring agent work persists, replays, and is observable across runs by default.","Vercel's TypeScript-native agent framework with durable execution, sandboxed compute, and OpenTelemetry tracing built in, so recurring agent work persists, replays, and is observable across runs by default.","Vercel's TypeScript-native agent framework with durable execution, sandboxed compute, and OpenTelemetry tracing built in, so recurring agent work persists, replays, and is observable across runs by default.","Durable execution and replay are treated as first-class loop infrastructure. Vercel's TypeScript-native agent framework with durable execution, sandboxed compute, and OpenTelemetry tracing built in, so recurring agent work persists, replays, and is observable across runs by default.",Use Eve to choose an implementation surface for repeatable agent work.,"Inspectable GitHub source (3,810 stars; 348 forks; Apache-2.0 license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,1021,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1021,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;state,builder,source-implementation,ok,https://github.com/vercel/eve,GitHub - vercel/eve: The Framework for Building Agents Β· GitHub,The Framework for Building Agents. Contribute to vercel/eve development by creating an account on GitHub.,,2026-06-16,2026,vercel/eve,GitHub,,,,github-api,vercel/eve,3810,348,Apache-2.0,2026-06-16T10:51:20Z,2026-07-17T17:40:41Z,,2026-07-17T17:58:18+00:00 -ale-0398,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent-delegation,Paper,πŸ“„,Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework,https://arxiv.org/abs/2603.11445,external,arxiv.org,"Decomposes work into a dependency-aware DAG, runs domain agents in parallel, and uses an LLM verifier to drive adaptive replanning with configurable stop conditions, the verify-and-replan core of a reliable loop.","Decomposes work into a dependency-aware DAG, runs domain agents in parallel, and uses an LLM verifier to drive adaptive replanning with configurable stop conditions, the verify-and-replan core of a reliable loop.","Decomposes work into a dependency-aware DAG, runs domain agents in parallel, and uses an LLM verifier to drive adaptive replanning with configurable stop conditions, the verify-and-replan core of a reliable loop.","Control flow is represented as an inspectable graph rather than an opaque prompt loop. Decomposes work into a dependency-aware DAG, runs domain agents in parallel, and uses an LLM verifier to drive adaptive replanning with configurable stop conditions, the verify-and-replan core of a reliable loop.",Use Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework to choose an implementation surface for repeatable agent work.,Research source arXiv:2603.11445; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1022,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1022,,Build,build,"Choose runtimes, tools, and delegation surfaces.",delegation;verification;exit,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2603.11445,[2603.11445] Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework for Complex Query Resolution,"We present Verified Multi-Agent Orchestration (VMAO), a framework that coordinates specialized LLM-based agents through a verification-driven iterative loop. Given a complex query, our system decomposes it into a directed acyclic graph (DAG) of sub-questions, executes them through domain-specific agents in parallel, verifies result completeness via LLM-based evaluation, and adaptively replans to address gaps. The key contributions are: (1) dependency-aware parallel execution over a DAG of sub-questions with automatic context propagation, (2) verification-driven adaptive replanning that uses an LLM-based verifier as an orchestration-level coordination signal, and (3) configurable stop conditions that balance answer quality against resource usage. On 25 expert-curated market research queries, VMAO improves answer completeness from 3.1 to 4.2 and source quality from 2.6 to 4.1 (1-5 scale) compared to a single-agent baseline, demonstrating that orchestration-level verification is an effective mechanism for multi-agent quality assurance.",Xing Zhang; Yanwei Cui; Guanghui Wang; Wei Qiu; Ziyuan Li; Fangwei Han; Yajing Huang; Hengzhi Qiu; Bing Zhu; Peiyang He,2026-03-12,2026,arXiv,arXiv,,ICLR 2026 Workshop on MALGAI,cs.AI,arxiv-api,,,,,,,2603.11445,2026-07-17T17:58:18+00:00 +ale-0398,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent-delegation,Paper,πŸ“„,Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework,https://arxiv.org/abs/2603.11445,external,arxiv.org,"Decomposes work into a dependency-aware DAG, runs domain agents in parallel, and uses an LLM verifier to drive adaptive replanning with configurable stop conditions, the verify-and-replan core of a reliable loop.","Decomposes work into a dependency-aware DAG, runs domain agents in parallel, and uses an LLM verifier to drive adaptive replanning with configurable stop conditions, the verify-and-replan core of a reliable loop.","Decomposes work into a dependency-aware DAG, runs domain agents in parallel, and uses an LLM verifier to drive adaptive replanning with configurable stop conditions, the verify-and-replan core of a reliable loop.","Control flow is represented as an inspectable graph rather than an opaque prompt loop. Decomposes work into a dependency-aware DAG, runs domain agents in parallel, and uses an LLM verifier to drive adaptive replanning with configurable stop conditions, the verify-and-replan core of a reliable loop.",Use Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework to choose an implementation surface for repeatable agent work.,Research source arXiv:2603.11445; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1022,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1022,,Build,build,"Choose runtimes, tools, and delegation surfaces.",delegation;verification;exit,researcher;evaluator,research-paper,ok,https://openreview.net/forum?id=WUmz4LUbvU,[2603.11445] Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework for Complex Query Resolution,"We present Verified Multi-Agent Orchestration (VMAO), a framework that coordinates specialized LLM-based agents through a verification-driven iterative loop. Given a complex query, our system decomposes it into a directed acyclic graph (DAG) of sub-questions, executes them through domain-specific agents in parallel, verifies result completeness via LLM-based evaluation, and adaptively replans to address gaps. The key contributions are: (1) dependency-aware parallel execution over a DAG of sub-questions with automatic context propagation, (2) verification-driven adaptive replanning that uses an LLM-based verifier as an orchestration-level coordination signal, and (3) configurable stop conditions that balance answer quality against resource usage. On 25 expert-curated market research queries, VMAO improves answer completeness from 3.1 to 4.2 and source quality from 2.6 to 4.1 (1-5 scale) compared to a single-agent baseline, demonstrating that orchestration-level verification is an effective mechanism for multi-agent quality assurance.",Xing Zhang; Yanwei Cui; Guanghui Wang; Wei Qiu; Ziyuan Li; Fangwei Han; Yajing Huang; Hengzhi Qiu; Bing Zhu; Peiyang He,2026,2026,ICLR Workshop on Multi-Agent Learning: Generalization and Adaptation in Intelligence (MALGAI),International Conference on Learning Representations,,Published in ICLR Workshop on Multi-Agent Learning: Generalization and Adaptation in Intelligence (MALGAI); the linked arXiv record remains available for open access.,cs.AI,ICLR workshop OpenReview record,,,,,,,2603.11445,2026-07-17T17:58:18+00:00 ale-0399,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent-delegation,Paper,πŸ“„,From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents,https://arxiv.org/abs/2603.22386,external,arxiv.org,"Organizes how agent workflows are fixed ahead of time or generated and revised per run, and which evaluation signals drive that choice, a map of the design space for recurring loops.","Organizes how agent workflows are fixed ahead of time or generated and revised per run, and which evaluation signals drive that choice, a map of the design space for recurring loops.","Organizes how agent workflows are fixed ahead of time or generated and revised per run, and which evaluation signals drive that choice, a map of the design space for recurring loops.","Control flow is represented as an inspectable graph rather than an opaque prompt loop. Organizes how agent workflows are fixed ahead of time or generated and revised per run, and which evaluation signals drive that choice, a map of the design space for recurring loops.",Use From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents to choose an implementation surface for repeatable agent work.,Research source arXiv:2603.22386; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1023,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1023,,Build,build,"Choose runtimes, tools, and delegation surfaces.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2603.22386,[2603.22386] From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents,"Large language model (LLM)-based systems are becoming increasingly popular for solving tasks by constructing executable workflows that interleave LLM calls, information retrieval, tool use, code execution, memory updates, and verification. This survey reviews recent methods for designing and optimizing such workflows, which we treat as agentic computation graphs (ACGs). We organize the literature based on when workflow structure is determined, where structure refers to which components or agents are present, how they depend on each other, and how information flows between them. This lens distinguishes static methods, which fix a reusable workflow scaffold before deployment, from dynamic methods, which select, generate, or revise the workflow for a particular run before or during execution. We further organize prior work along three dimensions: when structure is determined, what part of the workflow is optimized, and which evaluation signals guide optimization (e.g., task metrics, verifier signals, preferences, or trace-derived feedback). We also distinguish reusable workflow templates, run-specific realized graphs, and execution traces, separating reusable design choices from the structures actually deployed in a given run and from realized runtime behavior. Finally, we outline a structure-aware evaluation perspective that complements downstream task metrics with graph-level properties, execution cost, robustness, and structural variation across inputs. Our goal is to provide a clear vocabulary, a unified framework for positioning new methods, a more comparable view of existing body of literature, and a more reproducible evaluation standard for future work in workflow optimizations for LLM agents.",Ling Yue; Kushal Raj Bhandari; Ching-Yun Ko; Dhaval Patel; Shuxin Lin; Nianjun Zhou; Jianxi Gao; Pin-Yu Chen; Shaowu Pan,2026-03-23,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2603.22386,2026-07-17T17:58:18+00:00 ale-0400,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent-delegation,Tool,🧰,Agent-as-a-Router,https://github.com/LanceZPF/agent-as-a-router,external,github.com,"Agentic model routing for coding agents reframed as a context-action-feedback loop (ACRouter: orchestrator, verifier, memory) that learns which LLM to route each task to from execution feedback rather than frozen priors, with the CodeRouterBench benchmark across 8 frontier models.","Agentic model routing for coding agents reframed as a context-action-feedback loop (ACRouter: orchestrator, verifier, memory) that learns which LLM to route each task to from execution feedback rather than frozen priors, with the CodeRouterBench benchmark across 8 frontier models.","Agentic model routing for coding agents reframed as a context-action-feedback loop (ACRouter: orchestrator, verifier, memory) that learns which LLM to route each task to from execution feedback rather than frozen priors, with the CodeRouterBench benchmark across 8 frontier models.","Verification is promoted from a final check to a loop-control signal. Agentic model routing for coding agents reframed as a context-action-feedback loop (ACRouter: orchestrator, verifier, memory) that learns which LLM to route each task to from execution feedback rather than frozen priors, with the CodeRouterBench benchmark across 8 frontier models.",Use Agent-as-a-Router to choose an implementation surface for repeatable agent work.,"Inspectable GitHub source (662 stars; 14 forks; MIT license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,1024,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1024,,Build,build,"Choose runtimes, tools, and delegation surfaces.",context;delegation;verification,builder,source-implementation,ok,https://github.com/LanceZPF/agent-as-a-router,GitHub - LanceZPF/agent-as-a-router: The official implementations of Agent-as-a-Router: Agentic Model Routing for Coding Tasks. Β· GitHub,The official implementations of Agent-as-a-Router: Agentic Model Routing for Coding Tasks. - LanceZPF/agent-as-a-router,,2026-06-20,2026,LanceZPF/agent-as-a-router,GitHub,,,,github-api,LanceZPF/agent-as-a-router,662,14,MIT,2026-06-20T16:00:51Z,2026-07-17T17:05:43Z,,2026-07-17T17:58:18+00:00 ale-0401,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent-delegation,Blog,πŸ“,Amp: Custom Agents,https://ampcode.com/news/custom-agents,external,ampcode.com,"Amp's plugin-defined custom agents that run as the main agent or as subagents, spawn parallel workers, join tool pipelines, and use thread actions to build background review threads that report results back to a parent thread.","Amp's plugin-defined custom agents that run as the main agent or as subagents, spawn parallel workers, join tool pipelines, and use thread actions to build background review threads that report results back to a parent thread.","Amp's plugin-defined custom agents that run as the main agent or as subagents, spawn parallel workers, join tool pipelines, and use thread actions to build background review threads that report results back to a parent thread.","The work separates roles across agents, verifiers, or orchestration layers. Amp's plugin-defined custom agents that run as the main agent or as subagents, spawn parallel workers, join tool pipelines, and use thread actions to build background review threads that report results back to a parent thread.",Use Amp: Custom Agents to choose an implementation surface for repeatable agent work.,"Contextual source from ampcode.com; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,1025,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1025,,Build,build,"Choose runtimes, tools, and delegation surfaces.",workspace;delegation,builder,practitioner-analysis,ok,https://ampcode.com/news/custom-agents,Custom Agents - Amp,"Plugins can now create agents, run them once, and keep talking to their threads.",,,,,ampcode.com,,,,domain-fallback,,,,,,,,2026-07-17T17:58:18+00:00 @@ -421,28 +421,28 @@ ale-0419,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent- ale-0420,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent-delegation,Docs,πŸ“š,Flows,https://docs.crewai.com/en/concepts/flows,external,docs.crewai.com,"Official event-driven workflow layer with typed state, branching and loops, persistence decorators, and resume or fork operations for long-running executions.","Official event-driven workflow layer with typed state, branching and loops, persistence decorators, and resume or fork operations for long-running executions.","Official event-driven workflow layer with typed state, branching and loops, persistence decorators, and resume or fork operations for long-running executions.","Primary-source operational guidance rather than commentary. Official event-driven workflow layer with typed state, branching and loops, persistence decorators, and resume or fork operations for long-running executions.",Use Flows to choose an implementation surface for repeatable agent work.,Primary official documentation from docs.crewai.com; use it for current product or standard behavior.,high,README.md,1044,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1044,2026-07-17,Build,build,"Choose runtimes, tools, and delegation surfaces.",trigger;state,builder,official-documentation,ok,https://docs.crewai.com/v1.15.4/en/concepts/flows,Flows - CrewAI,Learn how to create and manage AI workflows using CrewAI Flows.,CrewAI,,,CrewAI,CrewAI,,,,primary-page,,,,,,,,2026-07-17T17:58:18+00:00 ale-0421,Orchestration And Multi-Agent Delegation,orchestration-and-multi-agent-delegation,Docs,πŸ“š,Graph,https://strandsagents.com/docs/user-guide/concepts/multi-agent/graph/,external,strandsagents.com,"Official deterministic graph pattern for multi-agent dependencies and cycles, with shared execution state and explicit execution limits.","Official deterministic graph pattern for multi-agent dependencies and cycles, with shared execution state and explicit execution limits.","Official deterministic graph pattern for multi-agent dependencies and cycles, with shared execution state and explicit execution limits.","Primary-source operational guidance rather than commentary. Official deterministic graph pattern for multi-agent dependencies and cycles, with shared execution state and explicit execution limits.",Use Graph to choose an implementation surface for repeatable agent work.,Primary official documentation from strandsagents.com; use it for current product or standard behavior.,high,README.md,1045,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1045,2026-07-17,Build,build,"Choose runtimes, tools, and delegation surfaces.",delegation;state,builder,official-documentation,ok,https://strandsagents.com/docs/user-guide/concepts/multi-agent/graph/,Graph Multi-Agent Pattern | Strands Agents,The open source toolkit for building production agents.,Strands Agents,,,Strands Agents,Strands Agents,,,,primary-page,,,,,,,,2026-07-17T17:58:18+00:00 ale-0422,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,SWE-bench,https://www.swebench.com/,external,www.swebench.com,Benchmark for resolving real GitHub issues through code editing and tests.,Benchmark for resolving real GitHub issues through code editing and tests.,Benchmark for resolving real GitHub issues through code editing and tests.,The work turns loop quality into a measurable task or score. Benchmark for resolving real GitHub issues through code editing and tests.,Use SWE-bench to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1053,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1053,,Verify,verify,"Gate progress with tests, evals, and evidence.",intake;verification,researcher;evaluator,benchmark,ok,https://www.swebench.com/,SWE-bench Leaderboards,,,,,,swebench.com,,,,domain-fallback,,,,,,,,2026-07-17T17:58:18+00:00 -ale-0423,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,SWE-bench: Can Language Models Resolve Real-World GitHub Issues?,https://arxiv.org/abs/2310.06770,external,arxiv.org,Original SWE-bench paper.,Original SWE-bench paper.,Original SWE-bench paper.,Links loop design to measurable tasks where progress and failure can be compared. Original SWE-bench paper.,Use SWE-bench: Can Language Models Resolve Real-World GitHub Issues? to measure progress and gate completion with repeatable evidence.,Research source arXiv:2310.06770; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1054,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1054,,Verify,verify,"Gate progress with tests, evals, and evidence.",intake,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2310.06770,[2310.06770] SWE-bench: Can Language Models Resolve Real-World GitHub Issues?,"Language models have outpaced our ability to evaluate them effectively, but for their future development it is essential to study the frontier of their capabilities. We find real-world software engineering to be a rich, sustainable, and challenging testbed for evaluating the next generation of language models. To this end, we introduce SWE-bench, an evaluation framework consisting of $2,294$ software engineering problems drawn from real GitHub issues and corresponding pull requests across $12$ popular Python repositories. Given a codebase along with a description of an issue to be resolved, a language model is tasked with editing the codebase to address the issue. Resolving issues in SWE-bench frequently requires understanding and coordinating changes across multiple functions, classes, and even files simultaneously, calling for models to interact with execution environments, process extremely long contexts and perform complex reasoning that goes far beyond traditional code generation tasks. Our evaluations show that both state-of-the-art proprietary models and our fine-tuned model SWE-Llama can resolve only the simplest issues. The best-performing model, Claude 2, is able to solve a mere $1.96$% of the issues. Advances on SWE-bench represent steps towards LMs that are more practical, intelligent, and autonomous.",Carlos E. Jimenez; John Yang; Alexander Wettig; Shunyu Yao; Kexin Pei; Ofir Press; Karthik Narasimhan,2023-10-10,2023,arXiv,arXiv,,"Data, code, and leaderboard are available at https://www.swebench.com ICLR 2024, https://openreview.net/forum?id=VTF8yNQM66",cs.CL,arxiv-api,,,,,,,2310.06770,2026-07-17T17:58:18+00:00 -ale-0424,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,SWE-bench Goes Live,https://arxiv.org/abs/2505.23419,external,arxiv.org,Dynamic benchmark designed to reduce overfitting to static issue sets.,Dynamic benchmark designed to reduce overfitting to static issue sets.,Dynamic benchmark designed to reduce overfitting to static issue sets.,The work turns loop quality into a measurable task or score. Dynamic benchmark designed to reduce overfitting to static issue sets.,Use SWE-bench Goes Live to measure progress and gate completion with repeatable evidence.,Research source arXiv:2505.23419; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1055,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1055,,Verify,verify,"Gate progress with tests, evals, and evidence.",intake;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2505.23419,[2505.23419] SWE-bench Goes Live!,"The issue-resolving task, where a model generates patches to fix real-world bugs, has emerged as a critical benchmark for evaluating the capabilities of large language models (LLMs). While SWE-bench and its variants have become standard in this domain, they suffer from key limitations: they have not been updated since their initial releases, cover a narrow set of repositories, and depend heavily on manual effort for instance construction and environment setup. These factors hinder scalability and introduce risks of overfitting and data contamination. In this work, we present SWE-bench-Live, a live-updatable benchmark designed to overcome these challenges. Our initial release consists of 1,319 tasks derived from real GitHub issues created since 2024, spanning 93 repositories. Each task is accompanied by a dedicated Docker image to ensure reproducible execution. Central to our benchmark is \method, an automated curation pipeline that streamlines the entire process from instance creation to environment setup, removing manual bottlenecks and enabling scalability and continuous updates. We evaluate a range of state-of-the-art agent frameworks and LLMs on SWE-bench-Live, revealing a substantial performance gap compared to static benchmarks like SWE-bench, even under controlled evaluation conditions. To better understand this discrepancy, we perform detailed analyses across repository origin, issue recency, and task difficulty. By providing a fresh, diverse, and executable benchmark grounded in live repository activity, SWE-bench-Live facilitates rigorous, contamination-resistant evaluation of LLMs and agents in dynamic, real-world software development settings.",Linghao Zhang; Shilin He; Chaoyun Zhang; Yu Kang; Bowen Li; Chengxing Xie; Junhao Wang; Maoquan Wang; Yufan Huang; Shengyu Fu; Elsie Nallipogu; Qingwei Lin; Yingnong Dang; Saravan Rajmohan; Dongmei Zhang,2025-05-29,2025,arXiv,arXiv,,"Homepage: \url{https://swe-bench-live.github.io/}, Code: \url{https://github.com/SWE-bench-Live}, Dataset: \url{https://huggingface.co/SWE-bench-Live}",cs.SE,arxiv-api,,,,,,,2505.23419,2026-07-17T17:58:18+00:00 +ale-0423,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,SWE-bench: Can Language Models Resolve Real-World GitHub Issues?,https://arxiv.org/abs/2310.06770,external,arxiv.org,Original SWE-bench paper.,Original SWE-bench paper.,Original SWE-bench paper.,Links loop design to measurable tasks where progress and failure can be compared. Original SWE-bench paper.,Use SWE-bench: Can Language Models Resolve Real-World GitHub Issues? to measure progress and gate completion with repeatable evidence.,Research source arXiv:2310.06770; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1054,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1054,,Verify,verify,"Gate progress with tests, evals, and evidence.",intake,researcher;evaluator,research-paper,ok,https://proceedings.iclr.cc/paper_files/paper/2024/hash/edac78c3e300629acfe6cbe9ca88fb84-Abstract-Conference.html,[2310.06770] SWE-bench: Can Language Models Resolve Real-World GitHub Issues?,"Language models have outpaced our ability to evaluate them effectively, but for their future development it is essential to study the frontier of their capabilities. We find real-world software engineering to be a rich, sustainable, and challenging testbed for evaluating the next generation of language models. To this end, we introduce SWE-bench, an evaluation framework consisting of $2,294$ software engineering problems drawn from real GitHub issues and corresponding pull requests across $12$ popular Python repositories. Given a codebase along with a description of an issue to be resolved, a language model is tasked with editing the codebase to address the issue. Resolving issues in SWE-bench frequently requires understanding and coordinating changes across multiple functions, classes, and even files simultaneously, calling for models to interact with execution environments, process extremely long contexts and perform complex reasoning that goes far beyond traditional code generation tasks. Our evaluations show that both state-of-the-art proprietary models and our fine-tuned model SWE-Llama can resolve only the simplest issues. The best-performing model, Claude 2, is able to solve a mere $1.96$% of the issues. Advances on SWE-bench represent steps towards LMs that are more practical, intelligent, and autonomous.",Carlos E. Jimenez; John Yang; Alexander Wettig; Shunyu Yao; Kexin Pei; Ofir Press; Karthik Narasimhan,2024,2024,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published in International Conference on Learning Representations (ICLR); the linked arXiv record remains available for open access.,cs.CL,ICLR proceedings record,,,,,,,2310.06770,2026-07-17T17:58:18+00:00 +ale-0424,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,SWE-bench Goes Live,https://arxiv.org/abs/2505.23419,external,arxiv.org,Dynamic benchmark designed to reduce overfitting to static issue sets.,Dynamic benchmark designed to reduce overfitting to static issue sets.,Dynamic benchmark designed to reduce overfitting to static issue sets.,The work turns loop quality into a measurable task or score. Dynamic benchmark designed to reduce overfitting to static issue sets.,Use SWE-bench Goes Live to measure progress and gate completion with repeatable evidence.,Research source arXiv:2505.23419; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1055,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1055,,Verify,verify,"Gate progress with tests, evals, and evidence.",intake;verification,researcher;evaluator,research-paper,ok,https://proceedings.neurips.cc/paper_files/paper/2025/hash/d83c4a745789690f82e86d0ef752ae7c-Abstract-Datasets_and_Benchmarks_Track.html,[2505.23419] SWE-bench Goes Live!,"The issue-resolving task, where a model generates patches to fix real-world bugs, has emerged as a critical benchmark for evaluating the capabilities of large language models (LLMs). While SWE-bench and its variants have become standard in this domain, they suffer from key limitations: they have not been updated since their initial releases, cover a narrow set of repositories, and depend heavily on manual effort for instance construction and environment setup. These factors hinder scalability and introduce risks of overfitting and data contamination. In this work, we present SWE-bench-Live, a live-updatable benchmark designed to overcome these challenges. Our initial release consists of 1,319 tasks derived from real GitHub issues created since 2024, spanning 93 repositories. Each task is accompanied by a dedicated Docker image to ensure reproducible execution. Central to our benchmark is \method, an automated curation pipeline that streamlines the entire process from instance creation to environment setup, removing manual bottlenecks and enabling scalability and continuous updates. We evaluate a range of state-of-the-art agent frameworks and LLMs on SWE-bench-Live, revealing a substantial performance gap compared to static benchmarks like SWE-bench, even under controlled evaluation conditions. To better understand this discrepancy, we perform detailed analyses across repository origin, issue recency, and task difficulty. By providing a fresh, diverse, and executable benchmark grounded in live repository activity, SWE-bench-Live facilitates rigorous, contamination-resistant evaluation of LLMs and agents in dynamic, real-world software development settings.",Linghao Zhang; Shilin He; Chaoyun Zhang; Yu Kang; Bowen Li; Chengxing Xie; Junhao Wang; Maoquan Wang; Yufan Huang; Shengyu Fu; Elsie Nallipogu; Qingwei Lin; Yingnong Dang; Saravan Rajmohan; Dongmei Zhang,2025,2025,Advances in Neural Information Processing Systems 38: Datasets and Benchmarks Track (NeurIPS),Neural Information Processing Systems Foundation,,Published in Advances in Neural Information Processing Systems 38: Datasets and Benchmarks Track (NeurIPS); the linked arXiv record remains available for open access.,cs.SE,NeurIPS proceedings record,,,,,,,2505.23419,2026-07-17T17:58:18+00:00 ale-0425,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,Terminal-Bench,https://www.tbench.ai/,external,www.tbench.ai,Benchmark for agents operating in terminal environments.,Benchmark for agents operating in terminal environments.,Benchmark for agents operating in terminal environments.,The work turns loop quality into a measurable task or score. Benchmark for agents operating in terminal environments.,Use Terminal-Bench to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1056,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1056,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://www.tbench.ai/,Terminal-Bench,A benchmark for terminal agents,,,,,Terminal-Bench,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0426,Benchmarks And Evaluation,benchmarks-and-evaluation,Tool,🧰,Terminal-Bench repository,https://github.com/harbor-framework/terminal-bench,external,github.com,Open-source benchmark and harness for hard terminal tasks.,Open-source benchmark and harness for hard terminal tasks.,Open-source benchmark and harness for hard terminal tasks.,The work turns loop quality into a measurable task or score. Open-source benchmark and harness for hard terminal tasks.,Use Terminal-Bench repository to measure progress and gate completion with repeatable evidence.,"Inspectable GitHub source (2,459 stars; 558 forks; Apache-2.0 license; updated 2026-07-17); popularity is context, not proof of reliability.",medium,README.md,1057,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1057,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,builder;evaluator,source-implementation,ok,https://github.com/harbor-framework/terminal-bench,GitHub - harbor-framework/terminal-bench: A benchmark for LLMs on complicated tasks in the terminal Β· GitHub,A benchmark for LLMs on complicated tasks in the terminal - harbor-framework/terminal-bench,,2025-01-17,2025,harbor-framework/terminal-bench,GitHub,,,,github-api,harbor-framework/terminal-bench,2459,558,Apache-2.0,2025-01-17T22:34:26Z,2026-07-17T09:36:34Z,,2026-07-17T17:58:18+00:00 -ale-0427,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,AgentBench,https://arxiv.org/abs/2308.03688,external,arxiv.org,Multi-environment benchmark for evaluating LLMs as agents.,Multi-environment benchmark for evaluating LLMs as agents.,Multi-environment benchmark for evaluating LLMs as agents.,The work turns loop quality into a measurable task or score. Multi-environment benchmark for evaluating LLMs as agents.,Use AgentBench to measure progress and gate completion with repeatable evidence.,Research source arXiv:2308.03688; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1058,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1058,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2308.03688,[2308.03688] AgentBench: Evaluating LLMs as Agents,"The potential of Large Language Model (LLM) as agents has been widely acknowledged recently. Thus, there is an urgent need to quantitatively \textit{evaluate LLMs as agents} on challenging tasks in interactive environments. We present AgentBench, a multi-dimensional benchmark that consists of 8 distinct environments to assess LLM-as-Agent's reasoning and decision-making abilities. Our extensive test over \num API-based and open-sourced (OSS) LLMs shows that, while top commercial LLMs present a strong ability of acting as agents in complex environments, there is a significant disparity in performance between them and many OSS competitors that are no larger than 70B. We identify the typical reasons of failures in environments and LLMs, showing that poor long-term reasoning, decision-making, and instruction following abilities are the main obstacles for developing usable LLM agents. Improving instruction following and training on high quality multi-round alignment data could improve agent performance. And different from existing assumptions, training on code present ambivalent impacts on different agent tasks. Datasets, environments, and an integrated evaluation package for AgentBench are released at https://github.com/THUDM/AgentBench.",Xiao Liu; Hao Yu; Hanchen Zhang; Yifan Xu; Xuanyu Lei; Hanyu Lai; Yu Gu; Hangliang Ding; Kaiwen Men; Kejuan Yang; Shudan Zhang; Xiang Deng; Aohan Zeng; Zhengxiao Du; Chenhui Zhang; Sheng Shen; Tianjun Zhang; Yu Su; Huan Sun; Minlie Huang; Yuxiao Dong; Jie Tang,2023-08-07,2023,arXiv,arXiv,,Published in ICLR 2024,cs.AI,arxiv-api,,,,,,,2308.03688,2026-07-17T17:58:18+00:00 -ale-0428,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,WebArena,https://arxiv.org/abs/2307.13854,external,arxiv.org,Realistic web environment for autonomous agents.,Realistic web environment for autonomous agents.,Realistic web environment for autonomous agents.,Links loop design to measurable tasks where progress and failure can be compared. Realistic web environment for autonomous agents.,Use WebArena to measure progress and gate completion with repeatable evidence.,Research source arXiv:2307.13854; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1059,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1059,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2307.13854,[2307.13854] WebArena: A Realistic Web Environment for Building Autonomous Agents,"With advances in generative AI, there is now potential for autonomous agents to manage daily tasks via natural language commands. However, current agents are primarily created and tested in simplified synthetic environments, leading to a disconnect with real-world scenarios. In this paper, we build an environment for language-guided agents that is highly realistic and reproducible. Specifically, we focus on agents that perform tasks on the web, and create an environment with fully functional websites from four common domains: e-commerce, social forum discussions, collaborative software development, and content management. Our environment is enriched with tools (e.g., a map) and external knowledge bases (e.g., user manuals) to encourage human-like task-solving. Building upon our environment, we release a set of benchmark tasks focusing on evaluating the functional correctness of task completions. The tasks in our benchmark are diverse, long-horizon, and designed to emulate tasks that humans routinely perform on the internet. We experiment with several baseline agents, integrating recent techniques such as reasoning before acting. The results demonstrate that solving complex tasks is challenging: our best GPT-4-based agent only achieves an end-to-end task success rate of 14.41%, significantly lower than the human performance of 78.24%. These results highlight the need for further development of robust agents, that current state-of-the-art large language models are far from perfect performance in these real-life tasks, and that WebArena can be used to measure such progress.",Shuyan Zhou; Frank F. Xu; Hao Zhu; Xuhui Zhou; Robert Lo; Abishek Sridhar; Xianyi Cheng; Tianyue Ou; Yonatan Bisk; Daniel Fried; Uri Alon; Graham Neubig,2023-07-25,2023,arXiv,arXiv,,"Our code, data, environment reproduction resources, and video demonstrations are publicly available at https://webarena.dev/",cs.AI,arxiv-api,,,,,,,2307.13854,2026-07-17T17:58:18+00:00 -ale-0429,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,OSWorld,https://arxiv.org/abs/2404.07972,external,arxiv.org,Benchmark for multimodal agents operating full computer environments.,Benchmark for multimodal agents operating full computer environments.,Benchmark for multimodal agents operating full computer environments.,The work turns loop quality into a measurable task or score. Benchmark for multimodal agents operating full computer environments.,Use OSWorld to measure progress and gate completion with repeatable evidence.,Research source arXiv:2404.07972; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1060,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1060,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2404.07972,[2404.07972] OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments,"Autonomous agents that accomplish complex computer tasks with minimal human interventions have the potential to transform human-computer interaction, significantly enhancing accessibility and productivity. However, existing benchmarks either lack an interactive environment or are limited to environments specific to certain applications or domains, failing to reflect the diverse and complex nature of real-world computer use, thereby limiting the scope of tasks and agent scalability. To address this issue, we introduce OSWorld, the first-of-its-kind scalable, real computer environment for multimodal agents, supporting task setup, execution-based evaluation, and interactive learning across various operating systems such as Ubuntu, Windows, and macOS. OSWorld can serve as a unified, integrated computer environment for assessing open-ended computer tasks that involve arbitrary applications. Building upon OSWorld, we create a benchmark of 369 computer tasks involving real web and desktop apps in open domains, OS file I/O, and workflows spanning multiple applications. Each task example is derived from real-world computer use cases and includes a detailed initial state setup configuration and a custom execution-based evaluation script for reliable, reproducible evaluation. Extensive evaluation of state-of-the-art LLM/VLM-based agents on OSWorld reveals significant deficiencies in their ability to serve as computer assistants. While humans can accomplish over 72.36% of the tasks, the best model achieves only 12.24% success, primarily struggling with GUI grounding and operational knowledge. Comprehensive analysis using OSWorld provides valuable insights for developing multimodal generalist agents that were not possible with previous benchmarks. Our code, environment, baseline models, and data are publicly available at https://os-world.github.io.",Tianbao Xie; Danyang Zhang; Jixuan Chen; Xiaochuan Li; Siheng Zhao; Ruisheng Cao; Toh Jing Hua; Zhoujun Cheng; Dongchan Shin; Fangyu Lei; Yitao Liu; Yiheng Xu; Shuyan Zhou; Silvio Savarese; Caiming Xiong; Victor Zhong; Tao Yu,2024-04-11,2024,arXiv,arXiv,,"51 pages, 21 figures",cs.AI,arxiv-api,,,,,,,2404.07972,2026-07-17T17:58:18+00:00 -ale-0430,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,ToolBench,https://arxiv.org/abs/2307.16789,external,arxiv.org,Tool-use benchmark and dataset for tool-augmented agents.,Tool-use benchmark and dataset for tool-augmented agents.,Tool-use benchmark and dataset for tool-augmented agents.,Packages the evidence as queryable CSV and JSONL rather than only a rendered page. Tool-use benchmark and dataset for tool-augmented agents.,Use ToolBench to measure progress and gate completion with repeatable evidence.,Research source arXiv:2307.16789; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1061,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1061,,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2307.16789,[2307.16789] ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs,"Despite the advancements of open-source large language models (LLMs), e.g., LLaMA, they remain significantly limited in tool-use capabilities, i.e., using external tools (APIs) to fulfill human instructions. The reason is that current instruction tuning largely focuses on basic language tasks but ignores the tool-use domain. This is in contrast to the excellent tool-use capabilities of state-of-the-art (SOTA) closed-source LLMs, e.g., ChatGPT. To bridge this gap, we introduce ToolLLM, a general tool-use framework encompassing data construction, model training, and evaluation. We first present ToolBench, an instruction-tuning dataset for tool use, which is constructed automatically using ChatGPT. Specifically, the construction can be divided into three stages: (i) API collection: we collect 16,464 real-world RESTful APIs spanning 49 categories from RapidAPI Hub; (ii) instruction generation: we prompt ChatGPT to generate diverse instructions involving these APIs, covering both single-tool and multi-tool scenarios; (iii) solution path annotation: we use ChatGPT to search for a valid solution path (chain of API calls) for each instruction. To enhance the reasoning capabilities of LLMs, we develop a novel depth-first search-based decision tree algorithm. It enables LLMs to evaluate multiple reasoning traces and expand the search space. Moreover, to evaluate the tool-use capabilities of LLMs, we develop an automatic evaluator: ToolEval. Based on ToolBench, we fine-tune LLaMA to obtain an LLM ToolLLaMA, and equip it with a neural API retriever to recommend appropriate APIs for each instruction. Experiments show that ToolLLaMA demonstrates a remarkable ability to execute complex instructions and generalize to unseen APIs, and exhibits comparable performance to ChatGPT. Our ToolLLaMA also demonstrates strong zero-shot generalization ability in an out-of-distribution tool-use dataset: APIBench.",Yujia Qin; Shihao Liang; Yining Ye; Kunlun Zhu; Lan Yan; Yaxi Lu; Yankai Lin; Xin Cong; Xiangru Tang; Bill Qian; Sihan Zhao; Lauren Hong; Runchu Tian; Ruobing Xie; Jie Zhou; Mark Gerstein; Dahai Li; Zhiyuan Liu; Maosong Sun,2023-07-31,2023,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2307.16789,2026-07-17T17:58:18+00:00 +ale-0427,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,AgentBench,https://arxiv.org/abs/2308.03688,external,arxiv.org,Multi-environment benchmark for evaluating LLMs as agents.,Multi-environment benchmark for evaluating LLMs as agents.,Multi-environment benchmark for evaluating LLMs as agents.,The work turns loop quality into a measurable task or score. Multi-environment benchmark for evaluating LLMs as agents.,Use AgentBench to measure progress and gate completion with repeatable evidence.,Research source arXiv:2308.03688; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1058,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1058,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-paper,ok,https://proceedings.iclr.cc/paper_files/paper/2024/hash/e9df36b21ff4ee211a8b71ee8b7e9f57-Abstract-Conference.html,[2308.03688] AgentBench: Evaluating LLMs as Agents,"The potential of Large Language Model (LLM) as agents has been widely acknowledged recently. Thus, there is an urgent need to quantitatively \textit{evaluate LLMs as agents} on challenging tasks in interactive environments. We present AgentBench, a multi-dimensional benchmark that consists of 8 distinct environments to assess LLM-as-Agent's reasoning and decision-making abilities. Our extensive test over \num API-based and open-sourced (OSS) LLMs shows that, while top commercial LLMs present a strong ability of acting as agents in complex environments, there is a significant disparity in performance between them and many OSS competitors that are no larger than 70B. We identify the typical reasons of failures in environments and LLMs, showing that poor long-term reasoning, decision-making, and instruction following abilities are the main obstacles for developing usable LLM agents. Improving instruction following and training on high quality multi-round alignment data could improve agent performance. And different from existing assumptions, training on code present ambivalent impacts on different agent tasks. Datasets, environments, and an integrated evaluation package for AgentBench are released at https://github.com/THUDM/AgentBench.",Xiao Liu; Hao Yu; Hanchen Zhang; Yifan Xu; Xuanyu Lei; Hanyu Lai; Yu Gu; Hangliang Ding; Kaiwen Men; Kejuan Yang; Shudan Zhang; Xiang Deng; Aohan Zeng; Zhengxiao Du; Chenhui Zhang; Sheng Shen; Tianjun Zhang; Yu Su; Huan Sun; Minlie Huang; Yuxiao Dong; Jie Tang,2024,2024,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published in International Conference on Learning Representations (ICLR); the linked arXiv record remains available for open access.,cs.AI,ICLR proceedings record,,,,,,,2308.03688,2026-07-17T17:58:18+00:00 +ale-0428,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,WebArena,https://arxiv.org/abs/2307.13854,external,arxiv.org,Realistic web environment for autonomous agents.,Realistic web environment for autonomous agents.,Realistic web environment for autonomous agents.,Links loop design to measurable tasks where progress and failure can be compared. Realistic web environment for autonomous agents.,Use WebArena to measure progress and gate completion with repeatable evidence.,Research source arXiv:2307.13854; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1059,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1059,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-paper,ok,https://proceedings.iclr.cc/paper_files/paper/2024/hash/4410c0711e9154a7a2d26f9b3816d1ef-Abstract-Conference.html,[2307.13854] WebArena: A Realistic Web Environment for Building Autonomous Agents,"With advances in generative AI, there is now potential for autonomous agents to manage daily tasks via natural language commands. However, current agents are primarily created and tested in simplified synthetic environments, leading to a disconnect with real-world scenarios. In this paper, we build an environment for language-guided agents that is highly realistic and reproducible. Specifically, we focus on agents that perform tasks on the web, and create an environment with fully functional websites from four common domains: e-commerce, social forum discussions, collaborative software development, and content management. Our environment is enriched with tools (e.g., a map) and external knowledge bases (e.g., user manuals) to encourage human-like task-solving. Building upon our environment, we release a set of benchmark tasks focusing on evaluating the functional correctness of task completions. The tasks in our benchmark are diverse, long-horizon, and designed to emulate tasks that humans routinely perform on the internet. We experiment with several baseline agents, integrating recent techniques such as reasoning before acting. The results demonstrate that solving complex tasks is challenging: our best GPT-4-based agent only achieves an end-to-end task success rate of 14.41%, significantly lower than the human performance of 78.24%. These results highlight the need for further development of robust agents, that current state-of-the-art large language models are far from perfect performance in these real-life tasks, and that WebArena can be used to measure such progress.",Shuyan Zhou; Frank F. Xu; Hao Zhu; Xuhui Zhou; Robert Lo; Abishek Sridhar; Xianyi Cheng; Tianyue Ou; Yonatan Bisk; Daniel Fried; Uri Alon; Graham Neubig,2024,2024,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published in International Conference on Learning Representations (ICLR); the linked arXiv record remains available for open access.,cs.AI,ICLR proceedings record,,,,,,,2307.13854,2026-07-17T17:58:18+00:00 +ale-0429,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,OSWorld,https://arxiv.org/abs/2404.07972,external,arxiv.org,Benchmark for multimodal agents operating full computer environments.,Benchmark for multimodal agents operating full computer environments.,Benchmark for multimodal agents operating full computer environments.,The work turns loop quality into a measurable task or score. Benchmark for multimodal agents operating full computer environments.,Use OSWorld to measure progress and gate completion with repeatable evidence.,Research source arXiv:2404.07972; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1060,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1060,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-paper,ok,https://proceedings.neurips.cc/paper_files/paper/2024/hash/5d413e48f84dc61244b6be550f1cd8f5-Abstract-Datasets_and_Benchmarks_Track.html,[2404.07972] OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments,"Autonomous agents that accomplish complex computer tasks with minimal human interventions have the potential to transform human-computer interaction, significantly enhancing accessibility and productivity. However, existing benchmarks either lack an interactive environment or are limited to environments specific to certain applications or domains, failing to reflect the diverse and complex nature of real-world computer use, thereby limiting the scope of tasks and agent scalability. To address this issue, we introduce OSWorld, the first-of-its-kind scalable, real computer environment for multimodal agents, supporting task setup, execution-based evaluation, and interactive learning across various operating systems such as Ubuntu, Windows, and macOS. OSWorld can serve as a unified, integrated computer environment for assessing open-ended computer tasks that involve arbitrary applications. Building upon OSWorld, we create a benchmark of 369 computer tasks involving real web and desktop apps in open domains, OS file I/O, and workflows spanning multiple applications. Each task example is derived from real-world computer use cases and includes a detailed initial state setup configuration and a custom execution-based evaluation script for reliable, reproducible evaluation. Extensive evaluation of state-of-the-art LLM/VLM-based agents on OSWorld reveals significant deficiencies in their ability to serve as computer assistants. While humans can accomplish over 72.36% of the tasks, the best model achieves only 12.24% success, primarily struggling with GUI grounding and operational knowledge. Comprehensive analysis using OSWorld provides valuable insights for developing multimodal generalist agents that were not possible with previous benchmarks. Our code, environment, baseline models, and data are publicly available at https://os-world.github.io.",Tianbao Xie; Danyang Zhang; Jixuan Chen; Xiaochuan Li; Siheng Zhao; Ruisheng Cao; Toh Jing Hua; Zhoujun Cheng; Dongchan Shin; Fangyu Lei; Yitao Liu; Yiheng Xu; Shuyan Zhou; Silvio Savarese; Caiming Xiong; Victor Zhong; Tao Yu,2024,2024,Advances in Neural Information Processing Systems 37: Datasets and Benchmarks Track (NeurIPS),Neural Information Processing Systems Foundation,10.52202/079017-1650,Published in Advances in Neural Information Processing Systems 37: Datasets and Benchmarks Track (NeurIPS); the linked arXiv record remains available for open access.,cs.AI,NeurIPS proceedings and DOI records,,,,,,,2404.07972,2026-07-17T17:58:18+00:00 +ale-0430,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,ToolBench,https://arxiv.org/abs/2307.16789,external,arxiv.org,Tool-use benchmark and dataset for tool-augmented agents.,Tool-use benchmark and dataset for tool-augmented agents.,Tool-use benchmark and dataset for tool-augmented agents.,Packages the evidence as queryable CSV and JSONL rather than only a rendered page. Tool-use benchmark and dataset for tool-augmented agents.,Use ToolBench to measure progress and gate completion with repeatable evidence.,Research source arXiv:2307.16789; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1061,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1061,,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace;verification,researcher;evaluator,research-paper,ok,https://proceedings.iclr.cc/paper_files/paper/2024/hash/28e50ee5b72e90b50e7196fde8ea260e-Abstract-Conference.html,[2307.16789] ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs,"Despite the advancements of open-source large language models (LLMs), e.g., LLaMA, they remain significantly limited in tool-use capabilities, i.e., using external tools (APIs) to fulfill human instructions. The reason is that current instruction tuning largely focuses on basic language tasks but ignores the tool-use domain. This is in contrast to the excellent tool-use capabilities of state-of-the-art (SOTA) closed-source LLMs, e.g., ChatGPT. To bridge this gap, we introduce ToolLLM, a general tool-use framework encompassing data construction, model training, and evaluation. We first present ToolBench, an instruction-tuning dataset for tool use, which is constructed automatically using ChatGPT. Specifically, the construction can be divided into three stages: (i) API collection: we collect 16,464 real-world RESTful APIs spanning 49 categories from RapidAPI Hub; (ii) instruction generation: we prompt ChatGPT to generate diverse instructions involving these APIs, covering both single-tool and multi-tool scenarios; (iii) solution path annotation: we use ChatGPT to search for a valid solution path (chain of API calls) for each instruction. To enhance the reasoning capabilities of LLMs, we develop a novel depth-first search-based decision tree algorithm. It enables LLMs to evaluate multiple reasoning traces and expand the search space. Moreover, to evaluate the tool-use capabilities of LLMs, we develop an automatic evaluator: ToolEval. Based on ToolBench, we fine-tune LLaMA to obtain an LLM ToolLLaMA, and equip it with a neural API retriever to recommend appropriate APIs for each instruction. Experiments show that ToolLLaMA demonstrates a remarkable ability to execute complex instructions and generalize to unseen APIs, and exhibits comparable performance to ChatGPT. Our ToolLLaMA also demonstrates strong zero-shot generalization ability in an out-of-distribution tool-use dataset: APIBench.",Yujia Qin; Shihao Liang; Yining Ye; Kunlun Zhu; Lan Yan; Yaxi Lu; Yankai Lin; Xin Cong; Xiangru Tang; Bill Qian; Sihan Zhao; Lauren Hong; Runchu Tian; Ruobing Xie; Jie Zhou; Mark Gerstein; Dahai Li; Zhiyuan Liu; Maosong Sun,2024,2024,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published in International Conference on Learning Representations (ICLR); the linked arXiv record remains available for open access.,cs.AI,ICLR proceedings record,,,,,,,2307.16789,2026-07-17T17:58:18+00:00 ale-0431,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,GAIA,https://arxiv.org/abs/2311.12983,external,arxiv.org,"Benchmark for general AI assistants requiring reasoning, tool use, and multi-step work.","Benchmark for general AI assistants requiring reasoning, tool use, and multi-step work.","Benchmark for general AI assistants requiring reasoning, tool use, and multi-step work.","The work turns loop quality into a measurable task or score. Benchmark for general AI assistants requiring reasoning, tool use, and multi-step work.",Use GAIA to measure progress and gate completion with repeatable evidence.,Research source arXiv:2311.12983; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1062,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1062,,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2311.12983,[2311.12983] GAIA: a benchmark for General AI Assistants,"We introduce GAIA, a benchmark for General AI Assistants that, if solved, would represent a milestone in AI research. GAIA proposes real-world questions that require a set of fundamental abilities such as reasoning, multi-modality handling, web browsing, and generally tool-use proficiency. GAIA questions are conceptually simple for humans yet challenging for most advanced AIs: we show that human respondents obtain 92\% vs. 15\% for GPT-4 equipped with plugins. This notable performance disparity contrasts with the recent trend of LLMs outperforming humans on tasks requiring professional skills in e.g. law or chemistry. GAIA's philosophy departs from the current trend in AI benchmarks suggesting to target tasks that are ever more difficult for humans. We posit that the advent of Artificial General Intelligence (AGI) hinges on a system's capability to exhibit similar robustness as the average human does on such questions. Using GAIA's methodology, we devise 466 questions and their answer. We release our questions while retaining answers to 300 of them to power a leader-board available at https://huggingface.co/gaia-benchmark.",GrΓ©goire Mialon; ClΓ©mentine Fourrier; Craig Swift; Thomas Wolf; Yann LeCun; Thomas Scialom,2023-11-21,2023,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,2311.12983,2026-07-17T17:58:18+00:00 ale-0432,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,Tau-bench,https://arxiv.org/abs/2406.12045,external,arxiv.org,Benchmark for tool-agent-user interactions in realistic domains.,Benchmark for tool-agent-user interactions in realistic domains.,Benchmark for tool-agent-user interactions in realistic domains.,The work turns loop quality into a measurable task or score. Benchmark for tool-agent-user interactions in realistic domains.,Use Tau-bench to measure progress and gate completion with repeatable evidence.,Research source arXiv:2406.12045; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1063,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1063,,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2406.12045,[2406.12045] $Ο„$-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains,"Existing benchmarks do not test language agents on their interaction with human users or ability to follow domain-specific rules, both of which are vital for deploying them in real world applications. We propose $\tau$-bench, a benchmark emulating dynamic conversations between a user (simulated by language models) and a language agent provided with domain-specific API tools and policy guidelines. We employ an efficient and faithful evaluation process that compares the database state at the end of a conversation with the annotated goal state. We also propose a new metric (pass^k) to evaluate the reliability of agent behavior over multiple trials. Our experiments show that even state-of-the-art function calling agents (like gpt-4o) succeed on <50% of the tasks, and are quite inconsistent (pass^8 <25% in retail). Our findings point to the need for methods that can improve the ability of agents to act consistently and follow rules reliably.",Shunyu Yao; Noah Shinn; Pedram Razavi; Karthik Narasimhan,2024-06-17,2024,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2406.12045,2026-07-17T17:58:18+00:00 -ale-0433,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,VisualWebArena,https://arxiv.org/abs/2401.13649,external,arxiv.org,Visually grounded web-agent benchmark extending WebArena.,Visually grounded web-agent benchmark extending WebArena.,Visually grounded web-agent benchmark extending WebArena.,The work turns loop quality into a measurable task or score. Visually grounded web-agent benchmark extending WebArena.,Use VisualWebArena to measure progress and gate completion with repeatable evidence.,Research source arXiv:2401.13649; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1064,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1064,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2401.13649,[2401.13649] VisualWebArena: Evaluating Multimodal Agents on Realistic Visual Web Tasks,"Autonomous agents capable of planning, reasoning, and executing actions on the web offer a promising avenue for automating computer tasks. However, the majority of existing benchmarks primarily focus on text-based agents, neglecting many natural tasks that require visual information to effectively solve. Given that most computer interfaces cater to human perception, visual information often augments textual data in ways that text-only models struggle to harness effectively. To bridge this gap, we introduce VisualWebArena, a benchmark designed to assess the performance of multimodal web agents on realistic \textit{visually grounded tasks}. VisualWebArena comprises of a set of diverse and complex web-based tasks that evaluate various capabilities of autonomous multimodal agents. To perform on this benchmark, agents need to accurately process image-text inputs, interpret natural language instructions, and execute actions on websites to accomplish user-defined objectives. We conduct an extensive evaluation of state-of-the-art LLM-based autonomous agents, including several multimodal models. Through extensive quantitative and qualitative analysis, we identify several limitations of text-only LLM agents, and reveal gaps in the capabilities of state-of-the-art multimodal language agents. VisualWebArena provides a framework for evaluating multimodal autonomous language agents, and offers insights towards building stronger autonomous agents for the web. Our code, baseline models, and data is publicly available at https://jykoh.com/vwa.",Jing Yu Koh; Robert Lo; Lawrence Jang; Vikram Duvvur; Ming Chong Lim; Po-Yu Huang; Graham Neubig; Shuyan Zhou; Ruslan Salakhutdinov; Daniel Fried,2024-01-24,2024,arXiv,arXiv,,Accepted to ACL 2024. 24 pages. Project page: https://jykoh.com/vwa,cs.LG,arxiv-api,,,,,,,2401.13649,2026-07-17T17:58:18+00:00 -ale-0434,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,AppWorld,https://arxiv.org/abs/2407.18901,external,arxiv.org,Benchmark of interactive app tasks with state-based and execution-based evaluation.,Benchmark of interactive app tasks with state-based and execution-based evaluation.,Benchmark of interactive app tasks with state-based and execution-based evaluation.,Evaluation data is used as the feedback signal for improving loop behavior. Benchmark of interactive app tasks with state-based and execution-based evaluation.,Use AppWorld to measure progress and gate completion with repeatable evidence.,Research source arXiv:2407.18901; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1065,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1065,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;state,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2407.18901,[2407.18901] AppWorld: A Controllable World of Apps and People for Benchmarking Interactive Coding Agents,"Autonomous agents that address day-to-day digital tasks (e.g., ordering groceries for a household), must not only operate multiple apps (e.g., notes, messaging, shopping app) via APIs, but also generate rich code with complex control flow in an iterative manner based on their interaction with the environment. However, existing benchmarks for tool use are inadequate, as they only cover tasks that require a simple sequence of API calls. To remedy this gap, we built $\textbf{AppWorld Engine}$, a high-quality execution environment (60K lines of code) of 9 day-to-day apps operable via 457 APIs and populated with realistic digital activities simulating the lives of ~100 fictitious users. We then created $\textbf{AppWorld Benchmark}$ (40K lines of code), a suite of 750 natural, diverse, and challenging autonomous agent tasks requiring rich and interactive code generation. It supports robust programmatic evaluation with state-based unit tests, allowing for different ways of completing a task while also checking for unexpected changes, i.e., collateral damage. The state-of-the-art LLM, GPT-4o, solves only ~49% of our 'normal' tasks and ~30% of 'challenge' tasks, while other models solve at least 16% fewer. This highlights the benchmark's difficulty and AppWorld's potential to push the frontiers of interactive coding agents. The project website is available at https://appworld.dev/.",Harsh Trivedi; Tushar Khot; Mareike Hartmann; Ruskin Manku; Vinty Dong; Edward Li; Shashank Gupta; Ashish Sabharwal; Niranjan Balasubramanian,2024-07-26,2024,arXiv,arXiv,,ACL'24 Camera Ready,cs.SE,arxiv-api,,,,,,,2407.18901,2026-07-17T17:58:18+00:00 +ale-0433,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,VisualWebArena,https://arxiv.org/abs/2401.13649,external,arxiv.org,Visually grounded web-agent benchmark extending WebArena.,Visually grounded web-agent benchmark extending WebArena.,Visually grounded web-agent benchmark extending WebArena.,The work turns loop quality into a measurable task or score. Visually grounded web-agent benchmark extending WebArena.,Use VisualWebArena to measure progress and gate completion with repeatable evidence.,Research source arXiv:2401.13649; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1064,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1064,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-paper,ok,https://aclanthology.org/2024.acl-long.50/,[2401.13649] VisualWebArena: Evaluating Multimodal Agents on Realistic Visual Web Tasks,"Autonomous agents capable of planning, reasoning, and executing actions on the web offer a promising avenue for automating computer tasks. However, the majority of existing benchmarks primarily focus on text-based agents, neglecting many natural tasks that require visual information to effectively solve. Given that most computer interfaces cater to human perception, visual information often augments textual data in ways that text-only models struggle to harness effectively. To bridge this gap, we introduce VisualWebArena, a benchmark designed to assess the performance of multimodal web agents on realistic \textit{visually grounded tasks}. VisualWebArena comprises of a set of diverse and complex web-based tasks that evaluate various capabilities of autonomous multimodal agents. To perform on this benchmark, agents need to accurately process image-text inputs, interpret natural language instructions, and execute actions on websites to accomplish user-defined objectives. We conduct an extensive evaluation of state-of-the-art LLM-based autonomous agents, including several multimodal models. Through extensive quantitative and qualitative analysis, we identify several limitations of text-only LLM agents, and reveal gaps in the capabilities of state-of-the-art multimodal language agents. VisualWebArena provides a framework for evaluating multimodal autonomous language agents, and offers insights towards building stronger autonomous agents for the web. Our code, baseline models, and data is publicly available at https://jykoh.com/vwa.",Jing Yu Koh; Robert Lo; Lawrence Jang; Vikram Duvvur; Ming Chong Lim; Po-Yu Huang; Graham Neubig; Shuyan Zhou; Ruslan Salakhutdinov; Daniel Fried,2024,2024,Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (ACL),Association for Computational Linguistics,10.18653/v1/2024.acl-long.50,Published in Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (ACL); the linked arXiv record remains available for open access.,cs.LG,ACL Anthology and DOI records,,,,,,,2401.13649,2026-07-17T17:58:18+00:00 +ale-0434,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,AppWorld,https://arxiv.org/abs/2407.18901,external,arxiv.org,Benchmark of interactive app tasks with state-based and execution-based evaluation.,Benchmark of interactive app tasks with state-based and execution-based evaluation.,Benchmark of interactive app tasks with state-based and execution-based evaluation.,Evaluation data is used as the feedback signal for improving loop behavior. Benchmark of interactive app tasks with state-based and execution-based evaluation.,Use AppWorld to measure progress and gate completion with repeatable evidence.,Research source arXiv:2407.18901; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1065,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1065,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;state,researcher;evaluator,research-paper,ok,https://aclanthology.org/2024.acl-long.850/,[2407.18901] AppWorld: A Controllable World of Apps and People for Benchmarking Interactive Coding Agents,"Autonomous agents that address day-to-day digital tasks (e.g., ordering groceries for a household), must not only operate multiple apps (e.g., notes, messaging, shopping app) via APIs, but also generate rich code with complex control flow in an iterative manner based on their interaction with the environment. However, existing benchmarks for tool use are inadequate, as they only cover tasks that require a simple sequence of API calls. To remedy this gap, we built $\textbf{AppWorld Engine}$, a high-quality execution environment (60K lines of code) of 9 day-to-day apps operable via 457 APIs and populated with realistic digital activities simulating the lives of ~100 fictitious users. We then created $\textbf{AppWorld Benchmark}$ (40K lines of code), a suite of 750 natural, diverse, and challenging autonomous agent tasks requiring rich and interactive code generation. It supports robust programmatic evaluation with state-based unit tests, allowing for different ways of completing a task while also checking for unexpected changes, i.e., collateral damage. The state-of-the-art LLM, GPT-4o, solves only ~49% of our 'normal' tasks and ~30% of 'challenge' tasks, while other models solve at least 16% fewer. This highlights the benchmark's difficulty and AppWorld's potential to push the frontiers of interactive coding agents. The project website is available at https://appworld.dev/.",Harsh Trivedi; Tushar Khot; Mareike Hartmann; Ruskin Manku; Vinty Dong; Edward Li; Shashank Gupta; Ashish Sabharwal; Niranjan Balasubramanian,2024,2024,Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (ACL),Association for Computational Linguistics,10.18653/v1/2024.acl-long.850,Published in Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (ACL); the linked arXiv record remains available for open access.,cs.SE,ACL Anthology and DOI records,,,,,,,2407.18901,2026-07-17T17:58:18+00:00 ale-0435,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,Vending-Bench,https://arxiv.org/abs/2502.15840,external,arxiv.org,Benchmark for long-term coherence of autonomous agents; documents how small errors compound over very long loop horizons.,Benchmark for long-term coherence of autonomous agents; documents how small errors compound over very long loop horizons.,Benchmark for long-term coherence of autonomous agents; documents how small errors compound over very long loop horizons.,The work turns loop quality into a measurable task or score. Benchmark for long-term coherence of autonomous agents; documents how small errors compound over very long loop horizons.,Use Vending-Bench to measure progress and gate completion with repeatable evidence.,Research source arXiv:2502.15840; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1066,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1066,,Verify,verify,"Gate progress with tests, evals, and evidence.",context;verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2502.15840,[2502.15840] Vending-Bench: A Benchmark for Long-Term Coherence of Autonomous Agents,"While Large Language Models (LLMs) can exhibit impressive proficiency in isolated, short-term tasks, they often fail to maintain coherent performance over longer time horizons. In this paper, we present Vending-Bench, a simulated environment designed to specifically test an LLM-based agent's ability to manage a straightforward, long-running business scenario: operating a vending machine. Agents must balance inventories, place orders, set prices, and handle daily fees - tasks that are each simple but collectively, over long horizons (>20M tokens per run) stress an LLM's capacity for sustained, coherent decision-making. Our experiments reveal high variance in performance across multiple LLMs: Claude 3.5 Sonnet and o3-mini manage the machine well in most runs and turn a profit, but all models have runs that derail, either through misinterpreting delivery schedules, forgetting orders, or descending into tangential ""meltdown"" loops from which they rarely recover. We find no clear correlation between failures and the point at which the model's context window becomes full, suggesting that these breakdowns do not stem from memory limits. Apart from highlighting the high variance in performance over long time horizons, Vending-Bench also tests models' ability to acquire capital, a necessity in many hypothetical dangerous AI scenarios. We hope the benchmark can help in preparing for the advent of stronger AI systems.",Axel Backlund; Lukas Petersson,2025-02-20,2025,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2502.15840,2026-07-17T17:58:18+00:00 ale-0436,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,Vending-Bench leaderboard,https://andonlabs.com/evals/vending-bench,external,andonlabs.com,Live long-horizon coherence results from Andon Labs.,Live long-horizon coherence results from Andon Labs.,Live long-horizon coherence results from Andon Labs.,The work turns loop quality into a measurable task or score. Live long-horizon coherence results from Andon Labs.,Use Vending-Bench leaderboard to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1067,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1067,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://andonlabs.com/evals/vending-bench,Vending-Bench: Testing long-term coherence in agents | Andon Labs,"How do agents act over very long horizons? We answer this by letting agents manage a simulated vending machine business. The agents need to handle ordering, inventory management, and pricing over long context horizons to successfully make money.",,,,,andonlabs.com,,,,domain-fallback,,,,,,,,2026-07-17T17:58:18+00:00 ale-0437,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios,https://arxiv.org/abs/2512.18470,external,arxiv.org,"Release-note-derived evolution tasks where agents score far below isolated-issue benchmarks, quantifying the long-horizon gap loops must manage.","Release-note-derived evolution tasks where agents score far below isolated-issue benchmarks, quantifying the long-horizon gap loops must manage.","Release-note-derived evolution tasks where agents score far below isolated-issue benchmarks, quantifying the long-horizon gap loops must manage.","The work turns loop quality into a measurable task or score. Release-note-derived evolution tasks where agents score far below isolated-issue benchmarks, quantifying the long-horizon gap loops must manage.",Use SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1068,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1068,,Verify,verify,"Gate progress with tests, evals, and evidence.",intake;verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2512.18470,[2512.18470] SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios,"Existing benchmarks for AI coding agents focus on isolated, single-issue tasks such as fixing a bug or adding a small feature. However, real-world software engineering is a long-horizon endeavor: developers interpret high-level requirements, coordinate changes across many files, and evolve codebases over multiple iterations while preserving functionality. We introduce SWE-EVO, a benchmark for this long-horizon software evolution challenge. Constructed from release notes of seven mature open-source Python projects, SWE-EVO comprises 48 tasks requiring multi-step modifications spanning an average of 21 files, validated against test suites averaging 874 tests per instance. Experiments reveal a striking capability gap: GPT-5.4 with OpenHands achieves only 25% on SWE-EVO versus 72.80% achieved by GPT-5.2 on SWE-Bench Verified, showing that current agents struggle with sustained, multi-file reasoning. We also propose Fix Rate, a metric capturing partial progress on these complex, long-horizon tasks.",Tue Le; Minh V. T. Thai; Dung Nguyen Manh; Huy Phan Nhat; Nghi D. Q. Bui,2025-12-20,2025,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2512.18470,2026-07-17T17:58:18+00:00 ale-0438,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,EvoSkills: Self-Evolving Agent Skills via Co-Evolutionary Verification,https://arxiv.org/abs/2604.01687,external,arxiv.org,"A skill generator and a co-evolving surrogate verifier improve multi-file skill packages over iterations, evaluated on the SkillsBench benchmark of structured skill bundles.","A skill generator and a co-evolving surrogate verifier improve multi-file skill packages over iterations, evaluated on the SkillsBench benchmark of structured skill bundles.","A skill generator and a co-evolving surrogate verifier improve multi-file skill packages over iterations, evaluated on the SkillsBench benchmark of structured skill bundles.","Verification is promoted from a final check to a loop-control signal. A skill generator and a co-evolving surrogate verifier improve multi-file skill packages over iterations, evaluated on the SkillsBench benchmark of structured skill bundles.",Use EvoSkills: Self-Evolving Agent Skills via Co-Evolutionary Verification to measure progress and gate completion with repeatable evidence.,Research source arXiv:2604.01687; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1069,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1069,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2604.01687,[2604.01687] CoEvoSkills: Self-Evolving Agent Skills via Co-Evolutionary Verification,"Anthropic proposes the concept of skills for LLM agents to tackle multi-step professional tasks that simple tool invocations cannot address. A tool is a single, self-contained function, whereas a skill is a structured bundle of interdependent multi-file artifacts. Currently, skill generation is not only label-intensive due to manual authoring, but also may suffer from human--machine cognitive misalignment, which can lead to degraded agent performance, as evidenced by evaluations on SkillsBench. Therefore, we aim to enable agents to autonomously generate skills. However, existing self-evolving methods designed for tools cannot be directly applied to skills due to their increased complexity. To address these issues, we propose CoEvoSkills, a self-evolving skills framework that enables agents to autonomously construct complex, multi-file skill packages. Specifically, CoEvoSkills couples a Skill Generator that iteratively refines skills with a Surrogate Verifier that co-evolves to provide informative and actionable feedback without access to ground-truth test content. On SkillsBench, CoEvoSkills achieves the highest pass rate among five baselines on both Claude Code and Codex, and also exhibits strong generalization capabilities to six additional LLMs.",Hanrong Zhang; Shicheng Fan; Henry Peng Zou; Yankai Chen; Zhenting Wang; Jiayu Zhou; Chengze Li; Wei-Chieh Huang; Yifei Yao; Kening Zheng; Xue Liu; Xiaoxiao Li; Philip S. Yu,2026-04-02,2026,arXiv,arXiv,,Code will be released,cs.AI,arxiv-api,,,,,,,2604.01687,2026-07-17T17:58:18+00:00 ale-0439,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,SaaSBench: Coding Agents in Long-Horizon Enterprise SaaS Engineering,https://arxiv.org/abs/2605.17526,external,arxiv.org,"Benchmark for agents on multi-dependency, interactive enterprise tasks, with automated evaluation that probes where long-horizon loops break down.","Benchmark for agents on multi-dependency, interactive enterprise tasks, with automated evaluation that probes where long-horizon loops break down.","Benchmark for agents on multi-dependency, interactive enterprise tasks, with automated evaluation that probes where long-horizon loops break down.","Evaluation data is used as the feedback signal for improving loop behavior. Benchmark for agents on multi-dependency, interactive enterprise tasks, with automated evaluation that probes where long-horizon loops break down.",Use SaaSBench: Coding Agents in Long-Horizon Enterprise SaaS Engineering to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1070,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1070,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2605.17526,[2605.17526] SaaSBench: Exploring the Boundaries of Coding Agents in Long-Horizon Enterprise SaaS Engineering,"As autonomous coding agents become capable of handling increasingly long-horizon tasks, they have gradually demonstrated the potential to complete end-to-end software development. Although existing benchmarks have recently evolved from localized code editing to from-scratch project generation, they remain confined to structurally simplified, single-stack applications. Consequently, they fail to capture the heterogeneous environments, full-stack orchestration, and system-level complexity of real enterprise Software as a Service (SaaS) systems, leaving a critical gap in assessing agents under realistic engineering constraints. To fill this gap, we introduce SaaSBench, the first benchmark designed to explore the boundaries of AI agents in enterprise SaaS engineering. Spanning 30 complex tasks across 6 SaaS domains with 5,370 validation nodes, it incorporates 8 programming languages, 6 databases, and 13 frameworks to meticulously mirror real-world software heterogeneity. Furthermore, we design a dependency-aware hybrid evaluation paradigm tailored for complex systems with long horizons and multi-component coupling, enabling fine-grained, reproducible assessment. Crucially, our extensive experiments reveal a striking insight: the primary bottleneck for state-of-the-art agents is not generating isolated code logic, but successfully configuring and integrating a multi-component system. Over 95\% of task failures occur before agents even reach deep business logic, with models often falling victim to overconfidence and prematurely halting during foundational system setup, or getting trapped in ineffective debugging loops. We hope SaaSBench serves as a practical and challenging testbed to drive the evolution of reliable, system-level coding agents. The code is available at \url{https://github.com/ShadeCloak/SaaSbench}.",Qingnan Ren; Shun Zou; Shiting Huang; Ziao Zhang; Kou Shi; Zhen Fang; Yiming Zhao; Yu Zeng; Qisheng Su; Lin Chen; Yong Wang; Zehui Chen; Xiangxiang Chu; Feng Zhao,2026-05-17,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2605.17526,2026-07-17T17:58:18+00:00 ale-0440,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,RoadmapBench: Evaluating Long-Horizon Agentic Software Development Across Version Upgrades,https://arxiv.org/abs/2605.15846,external,arxiv.org,"115 real version-upgrade tasks across 17 repositories requiring multi-file changes (median ~3,700 lines), stressing how far agent loops sustain coherent, large-scale work.","115 real version-upgrade tasks across 17 repositories requiring multi-file changes (median ~3,700 lines), stressing how far agent loops sustain coherent, large-scale work.","115 real version-upgrade tasks across 17 repositories requiring multi-file changes (median ~3,700 lines), stressing how far agent loops sustain coherent, large-scale work.","The work targets tasks that exceed a single context window or prompt session. 115 real version-upgrade tasks across 17 repositories requiring multi-file changes (median ~3,700 lines), stressing how far agent loops sustain coherent, large-scale work.",Use RoadmapBench: Evaluating Long-Horizon Agentic Software Development Across Version Upgrades to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1071,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1071,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2605.15846,[2605.15846] RoadmapBench: Evaluating Long-Horizon Agentic Software Development Across Version Upgrades,"Coding agents are increasingly deployed in real software development, where a single version iteration requires months of coordinated work across many files. However, most existing benchmarks focus predominantly on single-issue bug fixes from Python repositories, with coarse pass/fail evaluation outcomes, and thus fail to capture long-horizon, multi-target development at real engineering scale. To address this gap, we present RoadmapBench, a benchmark of 115 long-horizon coding tasks grounded in real open-source version upgrades across 17 repositories and 5 programming languages. Each task places the agent on a source-version code snapshot and provides a multi-target roadmap instruction requiring it to implement the functionality introduced in the target version, with a median modification of 3,700 lines across 51 files. We conduct a systematic evaluation on thirteen frontier models and find that even the strongest, Claude-Opus-4.7, resolves only 39.1% of tasks, while the weakest achieves merely 5.2%, in stark contrast to existing bug-fix benchmarks, suggesting that long-horizon software development remains a largely unsolved problem.",Xinbo Xu; Ruihan Yang; Haiyang Shen; Wendong Xu; Bofei Gao; Ruoyu Wu; Kean Shi; Weichu Xie; Xuanzhong Chen; Ming Wu; Jason Zeng; Michael Heinrich; Elvis Zhang; Liang Chen; Kuan Li; Baobao Chang,2026-05-15,2026,arXiv,arXiv,,"30 pages, 15 figures",cs.SE,arxiv-api,,,,,,,2605.15846,2026-07-17T17:58:18+00:00 -ale-0441,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,RefactorBench: Evaluating Stateful Reasoning in Language Agents Through Code,https://arxiv.org/abs/2503.07832,external,arxiv.org,"Multi-file refactoring tasks that require tracking and carrying state across many steps, isolating the durable-state weakness that breaks long agent loops.","Multi-file refactoring tasks that require tracking and carrying state across many steps, isolating the durable-state weakness that breaks long agent loops.","Multi-file refactoring tasks that require tracking and carrying state across many steps, isolating the durable-state weakness that breaks long agent loops.","Durable execution and replay are treated as first-class loop infrastructure. Multi-file refactoring tasks that require tracking and carrying state across many steps, isolating the durable-state weakness that breaks long agent loops.",Use RefactorBench: Evaluating Stateful Reasoning in Language Agents Through Code to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1072,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1072,,Verify,verify,"Gate progress with tests, evals, and evidence.",state,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2503.07832,[2503.07832] RefactorBench: Evaluating Stateful Reasoning in Language Agents Through Code,"Recent advances in language model (LM) agents and function calling have enabled autonomous, feedback-driven systems to solve problems across various digital domains. To better understand the unique limitations of LM agents, we introduce RefactorBench, a benchmark consisting of 100 large handcrafted multi-file refactoring tasks in popular open-source repositories. Solving tasks within RefactorBench requires thorough exploration of dependencies across multiple files and strong adherence to relevant instructions. Every task is defined by 3 natural language instructions of varying specificity and is mutually exclusive, allowing for the creation of longer combined tasks on the same repository. Baselines on RefactorBench reveal that current LM agents struggle with simple compositional tasks, solving only 22% of tasks with base instructions, in contrast to a human developer with short time constraints solving 87%. Through trajectory analysis, we identify various unique failure modes of LM agents, and further explore the failure mode of tracking past actions. By adapting a baseline agent to condition on representations of state, we achieve a 43.9% improvement in solving RefactorBench tasks. We further extend our state-aware approach to encompass entire digital environments and outline potential directions for future research. RefactorBench aims to support the study of LM agents by providing a set of real-world, multi-hop tasks within the realm of code.",Dhruv Gautam; Spandan Garg; Jinu Jang; Neel Sundaresan; Roshanak Zilouchian Moghaddam,2025-03-10,2025,arXiv,arXiv,,ICLR 2025 Camera Ready,cs.AI,arxiv-api,,,,,,,2503.07832,2026-07-17T17:58:18+00:00 +ale-0441,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,RefactorBench: Evaluating Stateful Reasoning in Language Agents Through Code,https://arxiv.org/abs/2503.07832,external,arxiv.org,"Multi-file refactoring tasks that require tracking and carrying state across many steps, isolating the durable-state weakness that breaks long agent loops.","Multi-file refactoring tasks that require tracking and carrying state across many steps, isolating the durable-state weakness that breaks long agent loops.","Multi-file refactoring tasks that require tracking and carrying state across many steps, isolating the durable-state weakness that breaks long agent loops.","Durable execution and replay are treated as first-class loop infrastructure. Multi-file refactoring tasks that require tracking and carrying state across many steps, isolating the durable-state weakness that breaks long agent loops.",Use RefactorBench: Evaluating Stateful Reasoning in Language Agents Through Code to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1072,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1072,,Verify,verify,"Gate progress with tests, evals, and evidence.",state,researcher;evaluator,benchmark,ok,https://proceedings.iclr.cc/paper_files/paper/2025/hash/6b44ee74539ea77d6a0d50d468724371-Abstract-Conference.html,[2503.07832] RefactorBench: Evaluating Stateful Reasoning in Language Agents Through Code,"Recent advances in language model (LM) agents and function calling have enabled autonomous, feedback-driven systems to solve problems across various digital domains. To better understand the unique limitations of LM agents, we introduce RefactorBench, a benchmark consisting of 100 large handcrafted multi-file refactoring tasks in popular open-source repositories. Solving tasks within RefactorBench requires thorough exploration of dependencies across multiple files and strong adherence to relevant instructions. Every task is defined by 3 natural language instructions of varying specificity and is mutually exclusive, allowing for the creation of longer combined tasks on the same repository. Baselines on RefactorBench reveal that current LM agents struggle with simple compositional tasks, solving only 22% of tasks with base instructions, in contrast to a human developer with short time constraints solving 87%. Through trajectory analysis, we identify various unique failure modes of LM agents, and further explore the failure mode of tracking past actions. By adapting a baseline agent to condition on representations of state, we achieve a 43.9% improvement in solving RefactorBench tasks. We further extend our state-aware approach to encompass entire digital environments and outline potential directions for future research. RefactorBench aims to support the study of LM agents by providing a set of real-world, multi-hop tasks within the realm of code.",Dhruv Gautam; Spandan Garg; Jinu Jang; Neel Sundaresan; Roshanak Zilouchian Moghaddam,2025,2025,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published in International Conference on Learning Representations (ICLR); the linked arXiv record remains available for open access.,cs.AI,ICLR proceedings record,,,,,,,2503.07832,2026-07-17T17:58:18+00:00 ale-0442,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,RigorBench: Benchmarking Engineering Process Discipline in Autonomous AI Coding Agents,https://arxiv.org/abs/2606.22678,external,arxiv.org,"Scores planning, verification coverage, recovery, abstention, and atomic transitions (not just whether code passes), measuring the loop discipline that separates reliable agents from reckless trial-and-error.","Scores planning, verification coverage, recovery, abstention, and atomic transitions (not just whether code passes), measuring the loop discipline that separates reliable agents from reckless trial-and-error.","Scores planning, verification coverage, recovery, abstention, and atomic transitions (not just whether code passes), measuring the loop discipline that separates reliable agents from reckless trial-and-error.","Verification is promoted from a final check to a loop-control signal. Scores planning, verification coverage, recovery, abstention, and atomic transitions (not just whether code passes), measuring the loop discipline that separates reliable agents from reckless trial-and-error.",Use RigorBench: Benchmarking Engineering Process Discipline in Autonomous AI Coding Agents to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1073,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1073,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2606.22678,[2606.22678] RigorBench: Benchmarking Engineering Process Discipline in Autonomous AI Coding Agents,"Agentic coding harnesses - such as Agent-Skills, Superpowers, and Agent-Rigor - are increasingly deployed to augment underlying LLMs for real-world software engineering tasks. Existing benchmarks evaluate these agents almost exclusively on outcome correctness: whether generated code passes tests or resolves issues. We argue that this outcome-only lens is insufficient: an agent that arrives at a correct solution through reckless trial-and-error, without planning, verification, or graceful recovery, is fundamentally less reliable than one that follows sound engineering discipline. We introduce RigorBench, the first benchmark designed to measure process discipline in AI coding agents. RigorBench evaluates these harnesses across five pillars: Planning Fidelity, Verification Coverage, Recovery Efficiency, Abstention Quality, and Atomic Transition Integrity. A composite RigorScore aggregates these dimensions into a single metric via a weighted sum. We curate a suite of 30 tasks spanning five categories - Plan-Then-Build, Verify-Or-Die, Doom Loop Gauntlet, Know When to Fold, and Don't Break the Build-and evaluate leading harnesses in a controlled with/without experimental design against baseline coding assistants. Our results show that structured process discipline not only improves process quality scores by an average of 41% but also raises downstream outcome correctness by 17%, providing the first quantitative evidence that how agents code matters as much as what they produce. We release the full benchmark, scoring rubrics, and trajectory analysis tools as open-source artifacts.",Meher Bhaskar Madiraju; Meher Sai Preetam Madiraju,2026-06-21,2026,arXiv,arXiv,,"9 pages, 7 tables, 1 figure",cs.SE,arxiv-api,,,,,,,2606.22678,2026-07-17T17:58:18+00:00 ale-0443,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long-Horizon Iterative Tasks,https://arxiv.org/abs/2603.24755,external,arxiv.org,"Quantifies structural erosion and verbosity creep across iteration checkpoints in native harnesses like Claude Code and Codex, evidence for why loops need verification and budgets.","Quantifies structural erosion and verbosity creep across iteration checkpoints in native harnesses like Claude Code and Codex, evidence for why loops need verification and budgets.","Quantifies structural erosion and verbosity creep across iteration checkpoints in native harnesses like Claude Code and Codex, evidence for why loops need verification and budgets.","Checkpointed state makes long-running agent work recoverable across failures. Quantifies structural erosion and verbosity creep across iteration checkpoints in native harnesses like Claude Code and Codex, evidence for why loops need verification and budgets.",Use SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long-Horizon Iterative Tasks to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1074,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1074,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;state;budget,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2603.24755,[2603.24755] SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long-Horizon Iterative Tasks,"Software development is iterative, yet agentic coding benchmarks hide design issues through their single-shot setup. Recent iterative benchmarks attempt to remedy this but heavily constrain an agent's design decision space, making it impossible to faithfully measure how their decisions shape future extensions. We introduce SlopCodeBench, a benchmark of 36 problems and 196 checkpoints where agents repeatedly extend their own solutions. Unlike prior iterative benchmarks, our evolving specifications demand architectural decisions but leave internal structure to the agent. We measure two forms of degradation: structural erosion (concentrated complexity) and verbosity (redundant code). Evaluating 15 coding agents across open and closed models, we find that no agent fully solves any problem end-to-end, and the best agent passes 14.8% of checkpoints. Quality degrades across checkpoints, with structural erosion rising in 77% of trajectories and verbosity in 75.5%. Compared to 473 open-source Python repositories, agent code is 2.3x more verbose and 2.0x more eroded, and the human repositories degrade less often and by smaller margins across their git histories. Explicit quality guidance reduces initial verbosity and erosion by up to a third, without affecting degradation rates. SlopCodeBench provides the first measurement of code degradation under iterative extension, revealing that agents pass checkpoints while producing code that erodes and bloats with each turn.",Gabriel Orlanski; Devjeet Roy; Alexander Yun; Changho Shin; Alex Gu; Albert Ge; Dyah Adila; Nicholas Roberts; Frederic Sala; Aws Albarghouthi,2026-03-25,2026,arXiv,arXiv,"10.5281/zenodo.18405900,",Code and Leaderboards are located at https://www.scbench.ai,cs.SE,arxiv-api,,,,,,,2603.24755,2026-07-17T17:58:18+00:00 -ale-0444,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,LongCLI-Bench: A Preliminary Benchmark for Long-horizon Agentic Programming in Command-Line Interfaces,https://arxiv.org/abs/2602.14337,external,arxiv.org,"Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.","Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.","Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.","The work turns loop quality into a measurable task or score. Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.",Use LongCLI-Bench: A Preliminary Benchmark for Long-horizon Agentic Programming in Command-Line Interfaces to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1075,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1075,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;exit,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2602.14337,[2602.14337] LongCLI-Bench: A Preliminary Benchmark and Study for Long-horizon Agentic Programming in Command-Line Interfaces,"Recent advances in AI-assisted programming have empowered agents to execute complex workflows via command-line interfaces, however, existing benchmarks are limited by short task horizons, data contamination from GitHub scraping, and a lack of fine-grained evaluation metrics, fail to rigorously evaluate the long-horizon planning and execution capabilities essential for realistic software engineering. To address these gaps, we introduce LongCLI-Bench, a comprehensive benchmark designed to evaluate agentic capabilities across long-horizon, realistic tasks. We curated 20 high-quality, long-horizon tasks from over 1,000 computer science assignments and real-world workflows, covering four engineering categories: from scratch, feature addition, bug fixing, and refactoring. We propose a dual-set testing protocol for LongCLI-Bench, which measures requirement fulfillment (fail-to-pass) and regression avoidance (pass-to-pass), and incorporates step-level scoring to pinpoint execution failures. Extensive experiments reveal that even state-of-the-art agents achieve pass rates below 20% in LongCLI-Bench. Step-level analysis further indicates that the majority of tasks stall at less than 30% completion, highlighting that critical failures often occur in the early stages. Although self-correction offers marginal gains, human-agent collaboration through plan injection and interactive guidance yields significantly higher improvements. These results highlight that future research must emphasize the development of synergistic human-agent workflows alongside advances in agents' planning and execution capabilities to overcome key challenges in long-horizon task performance.",Yukang Feng; Jianwen Sun; Zelai Yang; Jiaxin Ai; Chuanhao Li; Zizhen Li; Fanrui Zhang; Kang He; Rui Ma; Jifan Lin; Jie Sun; Yang Xiao; Sizhuo Zhou; Wenxiao Wu; Yiming Liu; Pengfei Liu; Yu Qiao; Shenglin Zhang; Kaipeng Zhang,2026-02-15,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2602.14337,2026-07-17T17:58:18+00:00 +ale-0444,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,LongCLI-Bench: A Preliminary Benchmark for Long-horizon Agentic Programming in Command-Line Interfaces,https://arxiv.org/abs/2602.14337,external,arxiv.org,"Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.","Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.","Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.","The work turns loop quality into a measurable task or score. Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.",Use LongCLI-Bench: A Preliminary Benchmark for Long-horizon Agentic Programming in Command-Line Interfaces to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1075,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1075,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;exit,researcher;evaluator,benchmark,ok,https://aclanthology.org/2026.findings-acl.1497/,[2602.14337] LongCLI-Bench: A Preliminary Benchmark and Study for Long-horizon Agentic Programming in Command-Line Interfaces,"Recent advances in AI-assisted programming have empowered agents to execute complex workflows via command-line interfaces, however, existing benchmarks are limited by short task horizons, data contamination from GitHub scraping, and a lack of fine-grained evaluation metrics, fail to rigorously evaluate the long-horizon planning and execution capabilities essential for realistic software engineering. To address these gaps, we introduce LongCLI-Bench, a comprehensive benchmark designed to evaluate agentic capabilities across long-horizon, realistic tasks. We curated 20 high-quality, long-horizon tasks from over 1,000 computer science assignments and real-world workflows, covering four engineering categories: from scratch, feature addition, bug fixing, and refactoring. We propose a dual-set testing protocol for LongCLI-Bench, which measures requirement fulfillment (fail-to-pass) and regression avoidance (pass-to-pass), and incorporates step-level scoring to pinpoint execution failures. Extensive experiments reveal that even state-of-the-art agents achieve pass rates below 20% in LongCLI-Bench. Step-level analysis further indicates that the majority of tasks stall at less than 30% completion, highlighting that critical failures often occur in the early stages. Although self-correction offers marginal gains, human-agent collaboration through plan injection and interactive guidance yields significantly higher improvements. These results highlight that future research must emphasize the development of synergistic human-agent workflows alongside advances in agents' planning and execution capabilities to overcome key challenges in long-horizon task performance.",Yukang Feng; Jianwen Sun; Zelai Yang; Jiaxin Ai; Chuanhao Li; Zizhen Li; Fanrui Zhang; Kang He; Rui Ma; Jifan Lin; Jie Sun; Yang Xiao; Sizhuo Zhou; Wenxiao Wu; Yiming Liu; Pengfei Liu; Yu Qiao; Shenglin Zhang; Kaipeng Zhang,2026,2026,Findings of the Association for Computational Linguistics: ACL,Association for Computational Linguistics,10.18653/v1/2026.findings-acl.1497,Published in Findings of the Association for Computational Linguistics: ACL; the linked arXiv record remains available for open access.,cs.SE,ACL Anthology and DOI records,,,,,,,2602.14337,2026-07-17T17:58:18+00:00 ale-0445,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,Can LLM-as-a-Judge Reliably Verify Rubrics in Agentic Scenarios?,https://arxiv.org/abs/2606.29920,external,arxiv.org,"Benchmark of 2,458 instances across research and coding domains measuring how reliably LLM judges verify rubrics on agent outputs, finding substantial noise even in strong models and quantifying the trade-offs of prompt design, batched evaluation, and majority voting.","Benchmark of 2,458 instances across research and coding domains measuring how reliably LLM judges verify rubrics on agent outputs, finding substantial noise even in strong models and quantifying the trade-offs of prompt design, batched evaluation, and majority voting.","Benchmark of 2,458 instances across research and coding domains measuring how reliably LLM judges verify rubrics on agent outputs, finding substantial noise even in strong models and quantifying the trade-offs of prompt design, batched evaluation, and majority voting.","Evaluation data is used as the feedback signal for improving loop behavior. Benchmark of 2,458 instances across research and coding domains measuring how reliably LLM judges verify rubrics on agent outputs, finding substantial noise even in strong models and quantifying the trade-offs of prompt design, batched evaluation, and majority voting.",Use Can LLM-as-a-Judge Reliably Verify Rubrics in Agentic Scenarios? to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1076,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1076,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2606.29920,[2606.29920] Can LLM-as-a-Judge Reliably Verify Rubrics in Agentic Scenarios?,"Rubric-based scoring has become a widely used paradigm in model evaluation, typically with LLM-as-a-Judge (LaaJ) for rubric scoring. However, the reliability of LaaJ for rubric scoring remains underexplored. This concern is especially pronounced in agentic scenarios, where long, complex outputs further challenge reliable scoring. To address this, we conduct a systematic meta-evaluation of LaaJ reliability for rubric verification. We introduce RuVerBench, the first benchmark for assessing LaaJ reliability in rubric verification for agentic scenarios. RuVerBench covers two prevalent agentic domains, deep research and agentic coding, with 2,458 instances, each containing a model-generated output, a rubric, and a human-annotated label indicating whether the output satisfies the rubric. Using RuVerBench, we evaluate numerous frontier LLMs and find that even the most advanced models achieve strong performance but still exhibit substantial noise. We further analyze the impact of key LaaJ strategies, including prompt design, batching, and majority voting, on rubric verification. We find that weaker models are more sensitive to prompt variations, batched verification presents a trade-off between accuracy and efficiency, and majority voting yields effective but diminishing returns. We have released our dataset and code to facilitate future research: https://github.com/THU-KEG/RuVerBench.",Yangda Peng; Yunjia Qi; Hao Peng; Haotian Xia; Guanzhong He; Xintong Shi; Richeng Xuan; Songyuanyi Lu; Yixian Liu; Zhichao Hu; Yuhong Liu; Lei Hou; Bin Xu; Juanzi Li,2026-06-29,2026,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,2606.29920,2026-07-17T17:58:18+00:00 ale-0446,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,SentinelBench: A Benchmark for Long-Running Monitoring Agents,https://arxiv.org/abs/2606.05342,external,arxiv.org,"Microsoft Research benchmark of 100 tasks across 10 synthetic web environments that evaluates long-running monitoring agents on whether they wait or act appropriately, scoring task completion, response speed, and resource efficiency.","Microsoft Research benchmark of 100 tasks across 10 synthetic web environments that evaluates long-running monitoring agents on whether they wait or act appropriately, scoring task completion, response speed, and resource efficiency.","Microsoft Research benchmark of 100 tasks across 10 synthetic web environments that evaluates long-running monitoring agents on whether they wait or act appropriately, scoring task completion, response speed, and resource efficiency.","The work turns loop quality into a measurable task or score. Microsoft Research benchmark of 100 tasks across 10 synthetic web environments that evaluates long-running monitoring agents on whether they wait or act appropriately, scoring task completion, response speed, and resource efficiency.",Use SentinelBench: A Benchmark for Long-Running Monitoring Agents to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1077,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1077,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;exit,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2606.05342,[2606.05342] SentinelBench: A Benchmark for Long-Running Monitoring Agents,"AI agents are increasingly asked to carry out work that spans minutes, hours, or longer. Yet the default model of agent behavior is continuous action: issuing tool calls, refreshing pages, searching for alternatives, or otherwise trying to force progress. This is the wrong approach for many long-running tasks, which are better served by a strategy of sustained attention. Instead, agents should monitor an environment, notice when an external event makes progress possible, then respond promptly without wasting resources while waiting. To measure progress on this class of tasks, we introduce SentinelBench, an open-source benchmark for time-evolving monitoring tasks. SentinelBench contains 100 tasks across 10 synthetic web environments, including email, calendars, finance, professional networking, and entertainment. Each environment exposes a live web interface and replays a scripted sequence of events, requiring agents to navigate and reason about web pages whose state shifts underfoot. SentinelBench measures task completion, reaction time, and resource use, exposing the tradeoff between responsiveness and cost. We report results across three models and two browser-agent harnesses, establishing performance baselines for future comparison and demonstrating how agent design choices can dramatically impact key metrics. Together, these results show that SentinelBench distinguishes meaningful differences in agent behavior.",Matheus Kunzler Maldaner; Adam Fourney; Amanda Swearngin; Hussein Mozannar; Gagan Bansal; Maya Murad; Rafah Hosn; Saleema Amershi,2026-06-03,2026,arXiv,arXiv,,"18 pages, 16 figures",cs.AI,arxiv-api,,,,,,,2606.05342,2026-07-17T17:58:18+00:00 ale-0447,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,SWE-Together: Evaluating Coding Agents in Interactive User Sessions,https://arxiv.org/abs/2606.29957,external,arxiv.org,"Multi-session coding benchmark of 109 repository-level tasks reconstructed from 11,260 recorded user-agent sessions, replayed with an LLM user simulator and scored on final correctness and the number of corrective feedback turns.","Multi-session coding benchmark of 109 repository-level tasks reconstructed from 11,260 recorded user-agent sessions, replayed with an LLM user simulator and scored on final correctness and the number of corrective feedback turns.","Multi-session coding benchmark of 109 repository-level tasks reconstructed from 11,260 recorded user-agent sessions, replayed with an LLM user simulator and scored on final correctness and the number of corrective feedback turns.","The work turns loop quality into a measurable task or score. Multi-session coding benchmark of 109 repository-level tasks reconstructed from 11,260 recorded user-agent sessions, replayed with an LLM user simulator and scored on final correctness and the number of corrective feedback turns.",Use SWE-Together: Evaluating Coding Agents in Interactive User Sessions to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1078,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1078,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2606.29957,[2606.29957] SWE-Together: Evaluating Coding Agents in Interactive User Sessions,"Most coding-agent benchmarks are static: an agent receives a complete task description up front and is judged only by its final code. Real coding assistance is interactive, with users clarifying goals, adding constraints, and correcting mistakes over multiple turns. We introduce SWE-Together, a multi-turn benchmark reconstructed from real user-agent coding sessions. To make real interactions verifiable, we curate 109 repository-level tasks from 11,260 recorded sessions, selecting sessions with recoverable repository states, clear user goals, and observable outcomes. To replay these interactions across agents, we build a reactive LLM-based user simulator that preserves the original users' intents and provides feedback when the coding agent's progress requires it. To evaluate agents as collaborators, we measure both final repository correctness and the number of corrective feedback turns required during the interaction. Experiments with frontier coding agents show that stronger agents generally achieve higher final success rates while requiring fewer interventions, suggesting an improved user experience.",Yifan Wu; Zhuokai Zhao; Songlin Li; Ho Hin Lee; Jiacheng Zhu; Shirley Wu; Tianhe Yu; Serena Li; Lizhu Zhang; Xiangjun Fan; Shengzhi Li,2026-06-29,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2606.29957,2026-07-17T17:58:18+00:00 @@ -452,7 +452,7 @@ ale-0450,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,SEAG ale-0451,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,EvoCode-Bench: Evaluating Coding Agents in Multi-Turn Iterative Interactions,https://arxiv.org/abs/2605.24110,external,arxiv.org,"Benchmark of 26 evolving coding tasks across 227 evaluation rounds using cumulative executable tests to check that agents keep prior requirements working as specifications change, with top agents reaching only about 50% on multi-turn success metrics.","Benchmark of 26 evolving coding tasks across 227 evaluation rounds using cumulative executable tests to check that agents keep prior requirements working as specifications change, with top agents reaching only about 50% on multi-turn success metrics.","Benchmark of 26 evolving coding tasks across 227 evaluation rounds using cumulative executable tests to check that agents keep prior requirements working as specifications change, with top agents reaching only about 50% on multi-turn success metrics.","Evaluation data is used as the feedback signal for improving loop behavior. Benchmark of 26 evolving coding tasks across 227 evaluation rounds using cumulative executable tests to check that agents keep prior requirements working as specifications change, with top agents reaching only about 50% on multi-turn success metrics.",Use EvoCode-Bench: Evaluating Coding Agents in Multi-Turn Iterative Interactions to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1082,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1082,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2605.24110,[2605.24110] EvoCode-Bench: Evaluating Coding Agents in Multi-Turn Iterative Interactions,"Coding agents are increasingly used as iterative development partners, but most benchmarks still evaluate one specification followed by one final assessment. This leaves out a basic question: can an agent keep its own codebase working as requirements change? We introduce EvoCode-Bench, a benchmark of 26 stateful coding tasks and 227 evaluated rounds. Each task preserves the agent's workspace for 5-15 rounds, states requirements through observable behavior, and uses cumulative executable tests to check new requirements and still-active prior ones. We evaluate 13 coding agents with two metrics: MT@4, a four-attempt fail-stop multi-round score, and SR, a single-round score from a reference-completed prior state. For most agents, SR exceeds MT@4 by 22-40 points. The gap also changes rankings: the highest-SR agent (78.9) ranks only third in persistent execution (44.0 MT@4). Even the strongest agents achieve only about 50% success on multi-turn metrics, and aggregate pass rate drops below half of round-1 performance by round 5. Failure analysis shows tier-dependent behavior: weaker agents fail early, while stronger agents survive long enough to expose specification-tracking and regression failures. We release the benchmark data and Harbor multi-turn infrastructure.",Haiyang Shen; Xuanzhong Chen; Wendong Xu; Yun Ma; Liang Chen; Kuan Li,2026-05-22,2026,arXiv,arXiv,,"Work in Progress; 32 pages, 10 figures, preprint",cs.AI,arxiv-api,,,,,,,2605.24110,2026-07-17T17:58:18+00:00 ale-0452,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,On the Reliability of Computer Use Agents,https://arxiv.org/abs/2604.17849,external,arxiv.org,"Repeated-execution study on OSWorld decomposing why computer-use agents fail tasks they previously completed, separating execution stochasticity, task-specification ambiguity, and behavioral variability as distinct causes of unreliability.","Repeated-execution study on OSWorld decomposing why computer-use agents fail tasks they previously completed, separating execution stochasticity, task-specification ambiguity, and behavioral variability as distinct causes of unreliability.","Repeated-execution study on OSWorld decomposing why computer-use agents fail tasks they previously completed, separating execution stochasticity, task-specification ambiguity, and behavioral variability as distinct causes of unreliability.","Links loop design to measurable tasks where progress and failure can be compared. Repeated-execution study on OSWorld decomposing why computer-use agents fail tasks they previously completed, separating execution stochasticity, task-specification ambiguity, and behavioral variability as distinct causes of unreliability.",Use On the Reliability of Computer Use Agents to measure progress and gate completion with repeatable evidence.,Research source arXiv:2604.17849; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1083,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1083,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2604.17849,[2604.17849] On the Reliability of Computer Use Agents,"Computer-use agents have rapidly improved on real-world tasks such as web navigation, desktop automation, and software interaction, in some cases surpassing human performance. Yet even when the task and model are unchanged, an agent that succeeds once may fail on a repeated execution of the same task. This raises a fundamental question: if an agent can succeed at a task once, what prevents it from doing so reliably? In this work, we study the sources of unreliability in computer-use agents through three factors: stochasticity during execution, ambiguity in task specification, and variability in agent behavior. We analyze these factors on OSWorld using repeated executions of the same task together with paired statistical tests that capture task-level changes across settings. Our analysis shows that reliability depends on both how tasks are specified and how agent behavior varies across executions. These findings suggest the need to evaluate agents under repeated execution, to allow agents to resolve task ambiguity through interaction, and to favor strategies that remain stable across runs.",Gonzalo Gonzalez-Pumariega; Saaket Agashe; Jiachen Yang; Ang Li; Xin Eric Wang,2026-04-20,2026,arXiv,arXiv,,"33 pages, 3 figures, 4 tables",cs.AI,arxiv-api,,,,,,,2604.17849,2026-07-17T17:58:18+00:00 ale-0453,Benchmarks And Evaluation,benchmarks-and-evaluation,Paper,πŸ“„,AgentLens: Revealing the Lucky Pass Problem in SWE-Agent Evaluation,https://arxiv.org/abs/2605.12925,external,arxiv.org,"Grades 2,614 SWE-agent trajectories across eight models to show that 10.7% of passing trajectories in its 1,815-trajectory evaluation subset are lucky trial-and-error successes, replacing binary pass/fail with process-quality tiers that shift model rankings.","Grades 2,614 SWE-agent trajectories across eight models to show that 10.7% of passing trajectories in its 1,815-trajectory evaluation subset are lucky trial-and-error successes, replacing binary pass/fail with process-quality tiers that shift model rankings.","Grades 2,614 SWE-agent trajectories across eight models to show that 10.7% of passing trajectories in its 1,815-trajectory evaluation subset are lucky trial-and-error successes, replacing binary pass/fail with process-quality tiers that shift model rankings.","Evaluation data is used as the feedback signal for improving loop behavior. Grades 2,614 SWE-agent trajectories across eight models to show that 10.7% of passing trajectories in its 1,815-trajectory evaluation subset are lucky trial-and-error successes, replacing binary pass/fail with process-quality tiers that shift model rankings.",Use AgentLens: Revealing the Lucky Pass Problem in SWE-Agent Evaluation to measure progress and gate completion with repeatable evidence.,Research source arXiv:2605.12925; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1084,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1084,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,research-preprint,ok,https://arxiv.org/abs/2605.12925,[2605.12925] AgentLens: Revealing The Lucky Pass Problem in SWE-Agent Evaluation,"Evaluation of software engineering (SWE) agents is dominated by a binary signal: whether the final patch passes the tests. This outcome-only view treats a principled solution and a chaotic trial-and-error process as equivalent. We show that this equivalence is empirically false. We evaluate 2,614 OpenHands trajectories from eight model backends on 60 SWE-bench Verified tasks. Of these, 47 have enough passing trajectories to construct task-level process references, yielding a 1,815-trajectory evaluation subset. Among passing trajectories in this subset, 10.7% exhibit behavior we call a Lucky Pass: regression cycles, blind retries, missing verification, or temporally disordered exploration, implementation, and verification. We introduce AgentLens, a framework for process-level assessment of SWE-agent trajectories, and define AgentLens-Bench, a dataset of 1,815 trajectories annotated with quality scores, waste signals, divergence points, and 47 task-level Prefix Tree Acceptor (PTA) references. AgentLens builds PTA references by merging multiple passing solutions for the same task, and uses a context-sensitive intent labeler to assign actions to Exploration, Implementation, Verification, or Orchestration based on trajectory history rather than tool identity alone. On AgentLens-Bench, the quality score separates passing trajectories into Lucky, Solid, and Ideal tiers and further decomposes Lucky Passes into five recurring mechanisms. Across the eight model backends, Lucky rates range from 0.5% to 23.2%, and some models move by as many as five rank positions when ranked by quality score instead of pass rate. We plan to release the project repository soon, including AgentLens-Bench artifacts, the AgentLens SDK, and the analysis tooling.",Priyam Sahoo; Gaurav Mittal; Xiaomin Li; Shengjie Ma; Benjamin Steenhoek; Pingping Lin; Yu Hu,2026-05-13,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2605.12925,2026-07-17T17:58:18+00:00 -ale-0454,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,ORLoopBench: Solver-in-the-Loop Benchmarks for Self-Correction,https://arxiv.org/abs/2601.21008,external,arxiv.org,"Formalizes infeasible-model debugging as a solver-in-the-loop process where each action triggers solver re-execution and infeasibility recomputation, giving deterministic verification for iterative repair in operations research.","Formalizes infeasible-model debugging as a solver-in-the-loop process where each action triggers solver re-execution and infeasibility recomputation, giving deterministic verification for iterative repair in operations research.","Formalizes infeasible-model debugging as a solver-in-the-loop process where each action triggers solver re-execution and infeasibility recomputation, giving deterministic verification for iterative repair in operations research.","Verification is promoted from a final check to a loop-control signal. Formalizes infeasible-model debugging as a solver-in-the-loop process where each action triggers solver re-execution and infeasibility recomputation, giving deterministic verification for iterative repair in operations research.",Use ORLoopBench: Solver-in-the-Loop Benchmarks for Self-Correction to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1085,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1085,,Verify,verify,"Gate progress with tests, evals, and evidence.",trigger;verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2601.21008,[2601.21008] ORLoopBench: Solver-in-the-Loop Benchmarks for Self-Correction and Behavioral Rationality in Operations Research,"Operations Research practitioners debug infeasible models through an iterative process: inspecting Irreducible Infeasible Subsystems ( IIS), identifying constraint conflicts, and repairing formulations until feasibility is restored. Existing LLM benchmarks mostly treat OR as one-shot translation from problem descriptions to solver code, omitting this diagnostic loop. We formalize infeasible-model repair as a solver-in-the-loop Markov Decision Process in which each action triggers solver re-execution and IIS recomputation, yielding deterministic, verifiable feedback. We introduce ORLoopBench, a benchmark suite with two components: OR-Debug-Bench releases 5,362 LP/MILP repair instances, while OR-Bias-Bench evaluates closed-form operational decision rationality across inventory settings. Solver-verified RLVR training enables an 8B model to surpass frontier APIs on LP repair (95.3% vs 92.4% RR @5), improves diagnostic behavior, and transfers to MILP repair. The same evaluation exposes semantic drift in whole-model code regeneration: feasible regenerated MILPs can solve the wrong problem. Process-level evaluation with solver oracles enables targeted training for reliable OR self-correction.",Ruicheng Ao; David Simchi-Levi; Xinshang Wang,2026-01-28,2026,arXiv,arXiv,,"58 pages, accepted by ICML 2026",cs.LG,arxiv-api,,,,,,,2601.21008,2026-07-17T17:58:18+00:00 +ale-0454,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,ORLoopBench: Solver-in-the-Loop Benchmarks for Self-Correction,https://arxiv.org/abs/2601.21008,external,arxiv.org,"Formalizes infeasible-model debugging as a solver-in-the-loop process where each action triggers solver re-execution and infeasibility recomputation, giving deterministic verification for iterative repair in operations research.","Formalizes infeasible-model debugging as a solver-in-the-loop process where each action triggers solver re-execution and infeasibility recomputation, giving deterministic verification for iterative repair in operations research.","Formalizes infeasible-model debugging as a solver-in-the-loop process where each action triggers solver re-execution and infeasibility recomputation, giving deterministic verification for iterative repair in operations research.","Verification is promoted from a final check to a loop-control signal. Formalizes infeasible-model debugging as a solver-in-the-loop process where each action triggers solver re-execution and infeasibility recomputation, giving deterministic verification for iterative repair in operations research.",Use ORLoopBench: Solver-in-the-Loop Benchmarks for Self-Correction to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1085,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1085,,Verify,verify,"Gate progress with tests, evals, and evidence.",trigger;verification,researcher;evaluator,benchmark,ok,https://openreview.net/pdf/16a0193aa4e71ffe6c921ac0081a66b525eea017.pdf,[2601.21008] ORLoopBench: Solver-in-the-Loop Benchmarks for Self-Correction and Behavioral Rationality in Operations Research,"Operations Research practitioners debug infeasible models through an iterative process: inspecting Irreducible Infeasible Subsystems ( IIS), identifying constraint conflicts, and repairing formulations until feasibility is restored. Existing LLM benchmarks mostly treat OR as one-shot translation from problem descriptions to solver code, omitting this diagnostic loop. We formalize infeasible-model repair as a solver-in-the-loop Markov Decision Process in which each action triggers solver re-execution and IIS recomputation, yielding deterministic, verifiable feedback. We introduce ORLoopBench, a benchmark suite with two components: OR-Debug-Bench releases 5,362 LP/MILP repair instances, while OR-Bias-Bench evaluates closed-form operational decision rationality across inventory settings. Solver-verified RLVR training enables an 8B model to surpass frontier APIs on LP repair (95.3% vs 92.4% RR @5), improves diagnostic behavior, and transfers to MILP repair. The same evaluation exposes semantic drift in whole-model code regeneration: feasible regenerated MILPs can solve the wrong problem. Process-level evaluation with solver oracles enables targeted training for reliable OR self-correction.",Ruicheng Ao; David Simchi-Levi; Xinshang Wang,2026,2026,"Proceedings of the 43rd International Conference on Machine Learning (ICML), PMLR 306",PMLR,,"Published in Proceedings of the 43rd International Conference on Machine Learning (ICML), PMLR 306; the linked arXiv record remains available for open access.",cs.LG,PMLR camera-ready record,,,,,,,2601.21008,2026-07-17T17:58:18+00:00 ale-0455,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,LongDS-Bench: On the Failure of Long-Horizon Agentic Data Analysis,https://arxiv.org/abs/2605.30434,external,arxiv.org,"Benchmark of 68 real-world data-analysis tasks built from Kaggle notebooks spanning 2,225 interactive turns, finding that long-horizon errors account for 52-69% of agent failures and that maintaining a correct analytical state is the core bottleneck.","Benchmark of 68 real-world data-analysis tasks built from Kaggle notebooks spanning 2,225 interactive turns, finding that long-horizon errors account for 52-69% of agent failures and that maintaining a correct analytical state is the core bottleneck.","Benchmark of 68 real-world data-analysis tasks built from Kaggle notebooks spanning 2,225 interactive turns, finding that long-horizon errors account for 52-69% of agent failures and that maintaining a correct analytical state is the core bottleneck.","The work turns loop quality into a measurable task or score. Benchmark of 68 real-world data-analysis tasks built from Kaggle notebooks spanning 2,225 interactive turns, finding that long-horizon errors account for 52-69% of agent failures and that maintaining a correct analytical state is the core bottleneck.",Use LongDS-Bench: On the Failure of Long-Horizon Agentic Data Analysis to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1086,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1086,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification;state,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2605.30434,[2605.30434] LongDS-Bench: On the Failure of Long-Horizon Agentic Data Analysis,"Real-world data analysis is inherently iterative, yet existing benchmarks mostly evaluate isolated or short interactive tasks, leaving agents' ability to track evolving analytical context over long horizons untested. We introduce LongDS, a benchmark for long-horizon, multi-turn data analysis where agents must maintain, update, restore, and compose evolving analytical states. LongDS comprises 68 tasks constructed from real-world Kaggle notebooks, spanning 2,225 turns across six domains including Geoscience, Business, and Education. Tasks are designed around state-evolution patterns (e.g., counterfactual perturbation, rollback, multi-state composition), with an average dependency span of 11.3 turns. Evaluating five state-of-the-art models, we find that the best model reaches only 48.45% average accuracy, performance drops nearly 47 points from early to late turns, and long-horizon errors account for 52%--69% of failures. Further analysis shows that additional agent steps do not necessarily improve performance, suggesting that the key bottleneck is maintaining a correct analytical state rather than increasing interaction budget. We release LongDS to support research on reliable long-horizon agentic data analysis. Code and data will be released at https://github.com/zjunlp/DataMind.",Kewei Xu; Xiaoben Lu; Shuofei Qiao; Zihan Ding; Haoming Xu; Lei Liang; Ningyu Zhang,2026-05-28,2026,arXiv,arXiv,,Ongoing work,cs.LG,arxiv-api,,,,,,,2605.30434,2026-07-17T17:58:18+00:00 ale-0456,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,MemoryArena: Benchmarking Agent Memory in Interdependent Multi-Session Agentic Tasks,https://arxiv.org/abs/2602.16313,external,arxiv.org,"Multi-session benchmark of interdependent agentic tasks where agents must distill earlier sessions into memory and use it to guide later actions, showing that near-saturated scores on long-context memory benchmarks fail to transfer.","Multi-session benchmark of interdependent agentic tasks where agents must distill earlier sessions into memory and use it to guide later actions, showing that near-saturated scores on long-context memory benchmarks fail to transfer.","Multi-session benchmark of interdependent agentic tasks where agents must distill earlier sessions into memory and use it to guide later actions, showing that near-saturated scores on long-context memory benchmarks fail to transfer.","The work turns loop quality into a measurable task or score. Multi-session benchmark of interdependent agentic tasks where agents must distill earlier sessions into memory and use it to guide later actions, showing that near-saturated scores on long-context memory benchmarks fail to transfer.",Use MemoryArena: Benchmarking Agent Memory in Interdependent Multi-Session Agentic Tasks to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1087,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1087,,Verify,verify,"Gate progress with tests, evals, and evidence.",context;verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2602.16313,[2602.16313] MemoryArena: Benchmarking Agent Memory in Interdependent Multi-Session Agentic Tasks,"Existing evaluations of agents with memory typically assess memorization and action in isolation. One class of benchmarks evaluates memorization by testing recall of past conversations or text but fails to capture how memory is used to guide future decisions. Another class focuses on agents acting in single-session tasks without the need for long-term memory. However, in realistic settings, memorization and action are tightly coupled: agents acquire memory while interacting with the environment, and subsequently rely on that memory to solve future tasks. To capture this setting, we introduce MemoryArena, a unified evaluation gym for benchmarking agent memory in multi-session Memory-Agent-Environment loops. The benchmark consists of human-crafted agentic tasks with explicitly interdependent subtasks, where agents must learn from earlier actions and feedback by distilling experiences into memory, and subsequently use that memory to guide later actions to solve the overall task. MemoryArena supports evaluation across web navigation, preference-constrained planning, progressive information search, and sequential formal reasoning, and reveals that agents with near-saturated performance on existing long-context memory benchmarks like LoCoMo perform poorly in our agentic setting, exposing a gap in current evaluations for agents with memory.",Zexue He; Yu Wang; Churan Zhi; Yuanzhe Hu; Tzu-Ping Chen; Lang Yin; Ze Chen; Tong Arthur Wu; Siru Ouyang; Zihan Wang; Jiaxin Pei; Julian McAuley; Yejin Choi; Alex Pentland,2026-02-18,2026,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,2602.16313,2026-07-17T17:58:18+00:00 ale-0457,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,Momento: Evaluating Persistent Memory and Reasoning with Multi-Session Agentic Conversations,https://arxiv.org/abs/2606.00832,external,arxiv.org,"Benchmark for persistent, tool-mediated task completion across multiple sessions, finding that agents fail by treating prior-session history as current context instead of stale state that needs re-validation.","Benchmark for persistent, tool-mediated task completion across multiple sessions, finding that agents fail by treating prior-session history as current context instead of stale state that needs re-validation.","Benchmark for persistent, tool-mediated task completion across multiple sessions, finding that agents fail by treating prior-session history as current context instead of stale state that needs re-validation.","The work turns loop quality into a measurable task or score. Benchmark for persistent, tool-mediated task completion across multiple sessions, finding that agents fail by treating prior-session history as current context instead of stale state that needs re-validation.",Use Momento: Evaluating Persistent Memory and Reasoning with Multi-Session Agentic Conversations to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1088,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1088,,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace;context;verification;state;exit,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2606.00832,[2606.00832] Momento: Evaluating Persistent Memory and Reasoning with Multi-Session Agentic Conversations,"Recent advances in agentic AI have enabled agents to complete complex tasks through tool use, reasoning, and multi-step planning. Yet existing benchmarks evaluate agents within a single session, ignoring past actions, stated preferences, and prior decisions that agents must integrate to fulfill personalized user goals. We introduce Momento, a benchmark for persistent agentic task completion in multi-session service environments, requiring agents to take consequential, tool-mediated actions while resolving temporal dependencies and evolving user goals across sessions. Experimental results reveal that current agents fail primarily through misestimation of user state, treating prior session history as a reliable proxy for current context rather than stale information requiring re-validation, highlighting a substantial gap between current agent capabilities and realistic long-horizon human-agent interaction.",Adril Putra Merin; David Anugraha; Ayu Purwarianti; Genta Indra Winata,2026-05-30,2026,arXiv,arXiv,,Preprint,cs.CL,arxiv-api,,,,,,,2606.00832,2026-07-17T17:58:18+00:00 @@ -466,7 +466,7 @@ ale-0464,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,PERF ale-0465,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,Benchmarking coding agents on Databricks' multi-million line codebase,https://www.databricks.com/blog/benchmarking-coding-agents-databricks-multi-million-line-codebase,external,www.databricks.com,"Databricks engineering post (July 8, 2026, authors including Matei Zaharia and Patrick Wendell) on an internal benchmark built from real merged PRs with test-suite verification, finding that models cluster into three capability tiers, token price is a poor proxy for end-to-end task cost, and harness choice matters, with their Pi harness sending about 3x less context per turn at equal quality.","Databricks engineering post (July 8, 2026, authors including Matei Zaharia and Patrick Wendell) on an internal benchmark built from real merged PRs with test-suite verification, finding that models cluster into three capability tiers, token price is a poor proxy for end-to-end task cost, and harness choice matters, with their Pi harness sending about 3x less context per turn at equal quality.","Databricks engineering post (July 8, 2026, authors including Matei Zaharia and Patrick Wendell) on an internal benchmark built from real merged PRs with test-suite verification, finding that models cluster into three capability tiers, token price is a poor proxy for end-to-end task cost, and harness choice matters, with their Pi harness sending about 3x less context per turn at equal quality.","Verification is promoted from a final check to a loop-control signal. Databricks engineering post (July 8, 2026, authors including Matei Zaharia and Patrick Wendell) on an internal benchmark built from real merged PRs with test-suite verification, finding that models cluster into three capability tiers, token price is a poor proxy for end-to-end task cost, and harness choice matters, with their Pi harness sending about 3x less context per turn at equal quality.",Use Benchmarking coding agents on Databricks' multi-million line codebase to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1096,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1096,,Verify,verify,"Gate progress with tests, evals, and evidence.",context;verification;budget,researcher;evaluator,benchmark,ok,https://www.databricks.com/blog/benchmarking-coding-agents-databricks-multi-million-line-codebase,Benchmarking Coding Agents on Databricks’ Multi-Million Line Codebase | Databricks Blog,"Databricks shares results from its internal coding benchmark, evaluating coding agents on a multi-million line codebase to optimize engineering cost and performance.",,2026,2026,,Databricks,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0466,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,UniClawBench: A Universal Benchmark for Proactive Agents on Real-World Tasks,https://arxiv.org/abs/2607.08768,external,arxiv.org,"Capability-driven benchmark of 400 bilingual tasks for proactive agents operating everyday tools in live Docker environments with step-level checkpoints, decomposed into five foundational capabilities, skill usage, exploration, long-context reasoning, multimodal understanding, and cross-platform coordination, so failures localize to a root-cause capability instead of mixing capabilities per task, with closed-loop evaluation using multiple agent roles to simulate human feedback without leaking grading criteria.","Capability-driven benchmark of 400 bilingual tasks for proactive agents operating everyday tools in live Docker environments with step-level checkpoints, decomposed into five foundational capabilities, skill usage, exploration, long-context reasoning, multimodal understanding, and cross-platform coordination, so failures localize to a root-cause capability instead of mixing capabilities per task, with closed-loop evaluation using multiple agent roles to simulate human feedback without leaking grading criteria.","Capability-driven benchmark of 400 bilingual tasks for proactive agents operating everyday tools in live Docker environments with step-level checkpoints, decomposed into five foundational capabilities, skill usage, exploration, long-context reasoning, multimodal understanding, and cross-platform coordination, so failures localize to a root-cause capability instead of mixing capabilities per task, with closed-loop evaluation using multiple agent roles to simulate human feedback without leaking grading criteria.","Checkpointed state makes long-running agent work recoverable across failures. Capability-driven benchmark of 400 bilingual tasks for proactive agents operating everyday tools in live Docker environments with step-level checkpoints, decomposed into five foundational capabilities, skill usage, exploration, long-context reasoning, multimodal understanding, and cross-platform coordination, so failures localize to a root-cause capability instead of mixing capabilities per task, with closed-loop evaluation using multiple agent roles to simulate human feedback without leaking grading criteria.",Use UniClawBench: A Universal Benchmark for Proactive Agents on Real-World Tasks to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1097,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1097,,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace;context;verification;state;escalation,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2607.08768,[2607.08768] UniClawBench: A Universal Benchmark for Proactive Agents on Real-World Tasks,"The rapid development of large language models and multimodal large language models has accelerated the emergence of proactive agents capable of operating everyday tools and assisting users in real-world environments. However, existing benchmarks struggle to evaluate such agents effectively, as they often rely on sandboxed environments and single-turn evaluation paradigms. Moreover, their scenario-based task taxonomies mix multiple model capabilities within the same task category, making it difficult to identify the root causes of agent failures. To address these limitations, we introduce UniClawBench, the first capability-driven benchmark designed to evaluate proactive agents in dynamic, real-world settings. UniClawBench is built around five foundational model capabilities: Skill Usage, Exploration, Long-Context Reasoning, Multimodal Understanding, and Cross-Platform Coordination. Based on these capabilities, we design 400 bilingual real-world tasks. Unlike previous benchmarks that rely on static, pre-recorded answers, our benchmark evaluates agents in live Docker containers using fine-grained, step-by-step completion checkpoints. Furthermore, we design a closed-loop evaluation strategy comprising an executor agent, a hidden supervisor agent, and a user agent to simulate realistic multi-turn human feedback without leaking grading criteria. To disentangle base model capabilities from framework-level design choices, we evaluate state-of-the-art models under multiple agent frameworks. Through comprehensive comparisons across both models and frameworks, we show how base model capabilities and agent framework designs jointly shape performance in real-world environments. To facilitate future research, we make our benchmark and code publicly available at https://github.com/HKU-MMLab/UniClawBench.",Zhekai Chen; Chengqi Duan; Kaiyue Sun; Bohao Li; Yuqing Wang; Manyuan Zhang; Xihui Liu,2026-07-09,2026,arXiv,arXiv,,Project Page: https://uniclawbench.github.io | GitHub Repo: https://github.com/HKU-MMLab/UniClawBench,cs.CL,arxiv-api,,,,,,,2607.08768,2026-07-17T17:58:18+00:00 ale-0467,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,SLBench: Evaluating How LLM Agents Follow Logical Relations in Skills,https://arxiv.org/abs/2607.09016,external,arxiv.org,"Benchmark for whether agent loops respect the logical relations inside skill files (preconditions, constraints, fallbacks): 70% of 5,000+ public skills contain at least one such relation, and on 86 executable cases leading coding agents show unsafe-behavior rates up to 70%, with an inference-time scaffold cutting violations by 63%.","Benchmark for whether agent loops respect the logical relations inside skill files (preconditions, constraints, fallbacks): 70% of 5,000+ public skills contain at least one such relation, and on 86 executable cases leading coding agents show unsafe-behavior rates up to 70%, with an inference-time scaffold cutting violations by 63%.","Benchmark for whether agent loops respect the logical relations inside skill files (preconditions, constraints, fallbacks): 70% of 5,000+ public skills contain at least one such relation, and on 86 executable cases leading coding agents show unsafe-behavior rates up to 70%, with an inference-time scaffold cutting violations by 63%.","The work turns loop quality into a measurable task or score. Benchmark for whether agent loops respect the logical relations inside skill files (preconditions, constraints, fallbacks): 70% of 5,000+ public skills contain at least one such relation, and on 86 executable cases leading coding agents show unsafe-behavior rates up to 70%, with an inference-time scaffold cutting violations by 63%.",Use SLBench: Evaluating How LLM Agents Follow Logical Relations in Skills to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1098,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1098,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2607.09016,[2607.09016] SLBench: Evaluating How LLM Agents Follow Logical Relations in Skills,"Agent skills extend LLM agents with reusable procedures, tools, and domain-specific workflows, but their safety depends on resolving dependencies among interacting instructions. We introduce SkillLogic, a framework for analyzing logical relations in skill files and constructing executable tests from them. Our taxonomy covers eight relation types, including preconditions that gate valid actions, constraints that limit how allowed actions may be performed, and fallbacks that specify recovery behavior after failure. Using SkillLogic, we scan over 5000 public skills and find that 70% contain at least one logical relation. We then construct SLBench, an 86-case executable benchmark from high-confidence, high-impact, and locally testable relations. Evaluating Codex and Claude Code across six LLM backbones shows unsafe rates up to 70%, with violations leading to privacy leaks, unsafe configuration changes, and incomplete cleanup. The human audit attributes failures to both agent capability gaps and low-salience skill text. We further show that SLGuard, a lightweight inference-time scaffold, reduces violations by 63% on targeted cases. Our results establish logical-relation following as a distinct reliability challenge for skill-guided agents.",Xuan Chen; Chengpeng Wang; Lu Yan; Xiangyu Zhang,2026-07-10,2026,arXiv,arXiv,,,cs.CR,arxiv-api,,,,,,,2607.09016,2026-07-17T17:58:18+00:00 -ale-0468,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,SWE-Milestone: Evaluating AI Agents on Continuous Software Evolution,https://arxiv.org/abs/2603.13428,external,arxiv.org,"Commit-history-derived milestone task streams where agents must preserve system integrity across successive runs - frontier-model scores collapse from >80% on isolated tasks to at most 38% in continuous settings, quantifying the error-accumulation gap loop engineering targets.","Commit-history-derived milestone task streams where agents must preserve system integrity across successive runs - frontier-model scores collapse from >80% on isolated tasks to at most 38% in continuous settings, quantifying the error-accumulation gap loop engineering targets.","Commit-history-derived milestone task streams where agents must preserve system integrity across successive runs - frontier-model scores collapse from >80% on isolated tasks to at most 38% in continuous settings, quantifying the error-accumulation gap loop engineering targets.","Links loop design to measurable tasks where progress and failure can be compared. Commit-history-derived milestone task streams where agents must preserve system integrity across successive runs - frontier-model scores collapse from >80% on isolated tasks to at most 38% in continuous settings, quantifying the error-accumulation gap loop engineering targets.",Use SWE-Milestone: Evaluating AI Agents on Continuous Software Evolution to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1099,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1099,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2603.13428,[2603.13428] SWE-Milestone: Evaluating AI Agents on Continuous Software Evolution,"Real-world software must continuously evolve to meet ever-changing and open-ended requirements. AI agents, increasingly deployed as long-running systems, are now entrusted to drive this evolution. Yet, existing benchmarks evaluate agents on isolated, one-off coding tasks, neglecting the temporal dependencies and technical debt inherent in real-world software evolution. To bridge this gap, we introduce DeepCommit, an agentic pipeline that reconstructs verifiable Milestone DAGs from noisy commit logs, where milestones are defined as functionally cohesive development goals. These executable sequences enable SWE-Milestone, a benchmark that evaluates agents on streams of milestone-level tasks, requiring them to sustain system integrity and limit error accumulation, dimensions of long-term software evolution largely missing from current benchmarks. Our evaluation of 12 frontier models across 4 agent frameworks reveals a critical vulnerability: overall performance scores drop significantly from >80% on isolated tasks to at most 38% in continuous settings, exposing agents' profound struggle with long-term maintenance and error propagation.",Gangda Deng; Zhaoling Chen; Zhongming Yu; Haoyang Fan; Yuhong Liu; Yuxin Yang; Dhruv Parikh; Rajgopal Kannan; Le Cong; Mengdi Wang; Qian Zhang; Viktor Prasanna; Xiangru Tang; Xingyao Wang,2026-03-13,2026,arXiv,arXiv,,ICML 2026,cs.SE,arxiv-api,,,,,,,2603.13428,2026-07-17T17:58:18+00:00 +ale-0468,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,SWE-Milestone: Evaluating AI Agents on Continuous Software Evolution,https://arxiv.org/abs/2603.13428,external,arxiv.org,"Commit-history-derived milestone task streams where agents must preserve system integrity across successive runs - frontier-model scores collapse from >80% on isolated tasks to at most 38% in continuous settings, quantifying the error-accumulation gap loop engineering targets.","Commit-history-derived milestone task streams where agents must preserve system integrity across successive runs - frontier-model scores collapse from >80% on isolated tasks to at most 38% in continuous settings, quantifying the error-accumulation gap loop engineering targets.","Commit-history-derived milestone task streams where agents must preserve system integrity across successive runs - frontier-model scores collapse from >80% on isolated tasks to at most 38% in continuous settings, quantifying the error-accumulation gap loop engineering targets.","Links loop design to measurable tasks where progress and failure can be compared. Commit-history-derived milestone task streams where agents must preserve system integrity across successive runs - frontier-model scores collapse from >80% on isolated tasks to at most 38% in continuous settings, quantifying the error-accumulation gap loop engineering targets.",Use SWE-Milestone: Evaluating AI Agents on Continuous Software Evolution to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1099,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1099,,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2603.13428,[2603.13428] SWE-Milestone: Evaluating AI Agents on Continuous Software Evolution,"Real-world software must continuously evolve to meet ever-changing and open-ended requirements. AI agents, increasingly deployed as long-running systems, are now entrusted to drive this evolution. Yet, existing benchmarks evaluate agents on isolated, one-off coding tasks, neglecting the temporal dependencies and technical debt inherent in real-world software evolution. To bridge this gap, we introduce DeepCommit, an agentic pipeline that reconstructs verifiable Milestone DAGs from noisy commit logs, where milestones are defined as functionally cohesive development goals. These executable sequences enable SWE-Milestone, a benchmark that evaluates agents on streams of milestone-level tasks, requiring them to sustain system integrity and limit error accumulation, dimensions of long-term software evolution largely missing from current benchmarks. Our evaluation of 12 frontier models across 4 agent frameworks reveals a critical vulnerability: overall performance scores drop significantly from >80% on isolated tasks to at most 38% in continuous settings, exposing agents' profound struggle with long-term maintenance and error propagation.",Gangda Deng; Zhaoling Chen; Zhongming Yu; Haoyang Fan; Yuhong Liu; Yuxin Yang; Dhruv Parikh; Rajgopal Kannan; Le Cong; Mengdi Wang; Qian Zhang; Viktor Prasanna; Xiangru Tang; Xingyao Wang,2026,2026,Proceedings of the 43rd International Conference on Machine Learning (ICML),PMLR,,Accepted at Proceedings of the 43rd International Conference on Machine Learning (ICML); the linked arXiv record is the available paper version.,cs.SE,Current arXiv acceptance note and official project record,,,,,,,2603.13428,2026-07-17T17:58:18+00:00 ale-0469,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,AgentAbstain: Do LLM Agents Know When Not to Act?,https://arxiv.org/abs/2607.10059,external,arxiv.org,"Benchmark measuring whether agents correctly abstain from acting when a task is underspecified, unsafe, or impossible, rather than proceeding anyway, a capability every unattended loop depends on for safe exits.","Benchmark measuring whether agents correctly abstain from acting when a task is underspecified, unsafe, or impossible, rather than proceeding anyway, a capability every unattended loop depends on for safe exits.","Benchmark measuring whether agents correctly abstain from acting when a task is underspecified, unsafe, or impossible, rather than proceeding anyway, a capability every unattended loop depends on for safe exits.","The work turns loop quality into a measurable task or score. Benchmark measuring whether agents correctly abstain from acting when a task is underspecified, unsafe, or impossible, rather than proceeding anyway, a capability every unattended loop depends on for safe exits.",Use AgentAbstain: Do LLM Agents Know When Not to Act? to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1100,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1100,2026-07-15,Verify,verify,"Gate progress with tests, evals, and evidence.",verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2607.10059,[2607.10059] AgentAbstain: Do LLM Agents Know When Not to Act?,"Agent systems based on large language models (LLMs) are increasingly deployed for autonomous tasks, yet existing evaluations mostly focus on task success rather than whether agents know when to abstain. This gap poses real risks: under ambiguity, conflicting constraints, or tool failures, agents may execute unintended and irreversible actions. To close this gap, we present the first systematic evaluation framework for agentic abstention: the calibrated ability of tool-using LLM agents to recognize when not to act. At its core, AgentAbstain is a paired-task benchmark built on an agent-native taxonomy of 8 abstention scenarios across pre-execution reasoning and runtime discovery. It contains 263 paired tasks across 42 executable sandbox environments, where each pair consists of a should-act task and a should-abstain variant produced through a controlled perturbation to the instruction, tool, or environment state. To scale this paired design and resist data contamination, we propose AbstainGen, a fully automated pipeline that synthesizes sandbox environments and generates paired tasks end-to-end, validated by deterministic replay and semantic LLM judges; fresh task instances can be regenerated on demand, and three independent annotators rate 94-98% of sampled tasks as well-designed. Across 17 frontier LLMs in 4 agent harnesses, the best agent (Gemini 3.1 Pro) achieves only 59.5% paired accuracy (correct on both the act and abstain sides of each paired task). More importantly, abstention capability is largely independent of general task-solving capability, indicating that scaling task-solving alone will not close this gap. We further identify failure modes such as post-hoc abstention, in which agents execute irreversible actions before recognizing abstention triggers. Our code and dataset are open-sourced at agentabstain.github.io.",Xun Liu; Yi Evie Zhang; Vira Kasprova; Parisa Rabbani; Pardis Sadat Zahraei; Tianyu Zhang; Ali Ebrahimpour-Boroojeny; Varun Chandrasekaran,2026-07-11,2026,arXiv,arXiv,,"56 pages, 13 figures",cs.AI,arxiv-api,,,,,,,2607.10059,2026-07-17T17:58:18+00:00 ale-0470,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,"Agents Don't Just Agree, They Remember: Benchmarking Persistent Sycophancy",https://arxiv.org/abs/2607.10526,external,arxiv.org,"Benchmark showing that once a stateful personal agent is nudged into a sycophantic stance, it persists across later sessions through memory, so single-turn sycophancy tests understate the risk in long-running agents.","Benchmark showing that once a stateful personal agent is nudged into a sycophantic stance, it persists across later sessions through memory, so single-turn sycophancy tests understate the risk in long-running agents.","Benchmark showing that once a stateful personal agent is nudged into a sycophantic stance, it persists across later sessions through memory, so single-turn sycophancy tests understate the risk in long-running agents.","The work turns loop quality into a measurable task or score. Benchmark showing that once a stateful personal agent is nudged into a sycophantic stance, it persists across later sessions through memory, so single-turn sycophancy tests understate the risk in long-running agents.","Use Agents Don't Just Agree, They Remember: Benchmarking Persistent Sycophancy to measure progress and gate completion with repeatable evidence.",Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1101,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1101,2026-07-15,Verify,verify,"Gate progress with tests, evals, and evidence.",context;verification;state,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2607.10526,"[2607.10526] Agents Don't Just Agree, They Remember: Benchmarking Persistent Sycophancy in Stateful Personal Agents","Stateful personal agents increasingly maintain long-term user profiles, episodic memories, and reusable skills. This persistence turns conversational sycophancy into a state-writing failure: accepted user-centric claims can be committed as lasting preferences, background facts, or workflows and later reused after the original conversation is gone. We call this persistent sycophancy and introduce the Personal Agent Sycophancy Benchmark (PASB), a 1,600-task benchmark that traces whether a conversational claim is accepted, written into durable agent state, and reused in a later neutral query. Unlike prior benchmarks that provide pre-written memories, PASB evaluates real agents (Hermes-Agent and OpenClaw) that decide what to store. It isolates the write process by combining four scenario framings with four temporal delivery patterns and separating a five-turn persist stage from a cleared three-turn query stage, ensuring downstream effects arise only from durable state. Across twelve models, the commit boundary is the key inflection point: downstream failure increases from 45.0% in session-only episodes to 71.9% after commitment, a consistent increase of 27.0 percentage points. Committed claims exhibit three write-time patterns: status promotion, attribution removal, and scope broadening. These patterns become stronger under memory-like or procedural framing, repeated reinforcement, and even across domain boundaries. These results show that agent sycophancy is fundamentally a state-writing governance problem. Once user content is committed to durable memory, safety must govern what agents write, not only what they say. PASB identifies the write-time controls needed to gate risky commits while preserving the source, role, and scope of stored content beyond response-level mitigations.",Xutao Mao; Liangjie Zhao; Leyao Wang; Rui Qian; Qiang Huang; Wentao Wang; Bo Han; Xiang Zheng; Cong Wang,2026-07-12,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2607.10526,2026-07-17T17:58:18+00:00 ale-0471,Benchmarks And Evaluation,benchmarks-and-evaluation,Benchmark,πŸ§ͺ,Set-shifting Behavioral Test for Harnessed Agents,https://arxiv.org/abs/2607.13396,external,arxiv.org,"Tests whether harnessed agents adapt when hidden tool reliability changes, paired with no-shift controls that separate genuine adaptation failures from ordinary task errors and expose routine lock-in.","Tests whether harnessed agents adapt when hidden tool reliability changes, paired with no-shift controls that separate genuine adaptation failures from ordinary task errors and expose routine lock-in.","Tests whether harnessed agents adapt when hidden tool reliability changes, paired with no-shift controls that separate genuine adaptation failures from ordinary task errors and expose routine lock-in.","Links loop design to measurable tasks where progress and failure can be compared. Tests whether harnessed agents adapt when hidden tool reliability changes, paired with no-shift controls that separate genuine adaptation failures from ordinary task errors and expose routine lock-in.",Use Set-shifting Behavioral Test for Harnessed Agents to measure progress and gate completion with repeatable evidence.,Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.,high,README.md,1102,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1102,2026-07-17,Verify,verify,"Gate progress with tests, evals, and evidence.",workspace;verification,researcher;evaluator,benchmark,ok,https://arxiv.org/abs/2607.13396,[2607.13396] Set-shifting Behavioral Test for Harnessed Agents,"What happens to an LLM agent's tool choice when the reliable tool silently changes within an ongoing session? We borrow set-shifting from cognitive psychology to study how well agents adapt to hidden reliability shifts. Our benchmark mounts tool-skill libraries with redundancies, where many tools solve the same task but differ in hidden reliability. In our evaluation framework, a branched schedule shifts the reliable tool group at hidden boundaries and pairs every shift with a no-shift control. We find that agents, by default, settle on a small recurring routine within a few turns of each boundary, with call shares concentrating on a few discrete values after each reliability shift. We score the set-shifting accuracy for each agent trajectory: the joint probability of routing to the target tool group in every post-shift window. We test open-weight LLMs in an open-source agentic harness and find qualitatively distinct failure modes across the same set of routines. We also find that set framing, how the toolset presents the alternatives as competing or complementary, shifts the routing dynamics.",Ziwei Ye,2026-07-15,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2607.13396,2026-07-17T17:58:18+00:00 @@ -514,7 +514,7 @@ ale-0512,"Critiques, Risks, And Limitations",critiques-risks-and-limitations,Cri ale-0513,"Critiques, Risks, And Limitations",critiques-risks-and-limitations,Critique,⚠️,"Loop Engineering, the Latest AI Buzzword, Still Needs Humans in the Loop",https://www.theregister.com/ai-and-ml/2026/06/24/loop-engineering-latest-ai-buzzword-still-needs-humans-in-the-loop/5261735,external,www.theregister.com,"The Register's report on the June 2026 loop-engineering discussion, collecting the Steinberger, Osmani, and Cherny quotes while arguing that vendor token-consumption incentives and model non-determinism keep humans in the loop.","The Register's report on the June 2026 loop-engineering discussion, collecting the Steinberger, Osmani, and Cherny quotes while arguing that vendor token-consumption incentives and model non-determinism keep humans in the loop.","The Register's report on the June 2026 loop-engineering discussion, collecting the Steinberger, Osmani, and Cherny quotes while arguing that vendor token-consumption incentives and model non-determinism keep humans in the loop.","Keeps adoption grounded in known failure modes, economics, and operational limits. The Register's report on the June 2026 loop-engineering discussion, collecting the Steinberger, Osmani, and Cherny quotes while arguing that vendor token-consumption incentives and model non-determinism keep humans in the loop.","Use Loop Engineering, the Latest AI Buzzword, Still Needs Humans in the Loop to bound risk before recurring or unattended execution.","Contextual source from www.theregister.com; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,1189,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1189,,Govern,govern,"Bound permissions, cost, failure, and escalation.",budget,operator;security,risk-analysis,ok,https://www.theregister.com/ai-and-ml/2026/06/24/loop-engineering-latest-ai-buzzword-still-needs-humans-in-the-loop/5261735,"Loop engineering, latest AI buzzword, still needs humans in the loop",Prompting less and automating more comes with a price,,2026-06-24,2026,,theregister,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0514,"Critiques, Risks, And Limitations",critiques-risks-and-limitations,Paper,πŸ“„,When Agents Do Not Stop: Uncovering Infinite Agentic Loops in LLM Agents,https://arxiv.org/abs/2607.01641,external,arxiv.org,"Characterizes infinite agentic loops, a failure class where unbounded feedback paths make agents repeat calls, tools, or handoffs forever, and ships IAL-Scan, a static analyzer that confirmed 68 real cases across 47 of 6,549 scanned agent projects at 91.9% precision.","Characterizes infinite agentic loops, a failure class where unbounded feedback paths make agents repeat calls, tools, or handoffs forever, and ships IAL-Scan, a static analyzer that confirmed 68 real cases across 47 of 6,549 scanned agent projects at 91.9% precision.","Characterizes infinite agentic loops, a failure class where unbounded feedback paths make agents repeat calls, tools, or handoffs forever, and ships IAL-Scan, a static analyzer that confirmed 68 real cases across 47 of 6,549 scanned agent projects at 91.9% precision.","Keeps adoption grounded in known failure modes, economics, and operational limits. Characterizes infinite agentic loops, a failure class where unbounded feedback paths make agents repeat calls, tools, or handoffs forever, and ships IAL-Scan, a static analyzer that confirmed 68 real cases across 47 of 6,549 scanned agent projects at 91.9% precision.",Use When Agents Do Not Stop: Uncovering Infinite Agentic Loops in LLM Agents to bound risk before recurring or unattended execution.,Research source arXiv:2607.01641; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1190,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1190,,Govern,govern,"Bound permissions, cost, failure, and escalation.",workspace;delegation;exit,researcher;evaluator;operator;security,research-preprint,ok,https://arxiv.org/abs/2607.01641,[2607.01641] When Agents Do Not Stop: Uncovering Infinite Agentic Loops in LLM Agents,"LLM agents increasingly rely on iterative execution to solve tasks through planning, tool use, state updates, and agent collaboration. While this design enables flexible automation, it also creates a new class of failures: an agent may repeatedly execute model calls, tools, workflow transitions, or agent handoffs when the feedback path is not effectively bounded. We call this problem Infinite Agentic Loops (IALs). IALs are not ordinary programming loops; they arise from the interaction between agent logic, framework semantics, runtime observations, and termination mechanisms. Such failures can amplify a single request into long running model and tool execution, causing cost exhaustion, model denial of service, context growth, and repeated external side effects. We propose IAL-Scan, a static analysis tool for detecting IAL failures in real-world LLM agent projects. IAL-Scan abstracts heterogeneous agent code into a framework independent Agent IR, builds an Agentic Loop Dependence Graph (ALDG) to recover explicit and framework induced feedback paths, and checks whether these paths can repeatedly reach costly or state growing operations without an effective bound. We evaluate IAL-Scan on 6,549 LLM agent repositories. It reports 74 potential findings, among which manual review confirms 68 IAL failures across 47 projects, achieving 91.9% precision.",Xinyi Hou; Shenao Wang; Yanjie Zhao; Haoyu Wang,2026-07-02,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,2607.01641,2026-07-17T17:58:18+00:00 ale-0515,"Critiques, Risks, And Limitations",critiques-risks-and-limitations,Paper,πŸ“„,The Blind Curator: How a Biased Judge Silently Disables Skill Retirement in Self-Evolving Agents,https://arxiv.org/abs/2607.07436,external,arxiv.org,Shows via corrupted-reward analysis that false-pass bias in an LLM judge silently disables the skill-retirement mechanism that keeps a self-evolving agent's growing skill library from drifting below the no-skill baseline.,Shows via corrupted-reward analysis that false-pass bias in an LLM judge silently disables the skill-retirement mechanism that keeps a self-evolving agent's growing skill library from drifting below the no-skill baseline.,Shows via corrupted-reward analysis that false-pass bias in an LLM judge silently disables the skill-retirement mechanism that keeps a self-evolving agent's growing skill library from drifting below the no-skill baseline.,"Keeps adoption grounded in known failure modes, economics, and operational limits. Shows via corrupted-reward analysis that false-pass bias in an LLM judge silently disables the skill-retirement mechanism that keeps a self-evolving agent's growing skill library from drifting below the no-skill baseline.",Use The Blind Curator: How a Biased Judge Silently Disables Skill Retirement in Self-Evolving Agents to bound risk before recurring or unattended execution.,Research source arXiv:2607.07436; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1191,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1191,,Govern,govern,"Bound permissions, cost, failure, and escalation.",budget;escalation;exit,researcher;evaluator;operator;security,research-preprint,ok,https://arxiv.org/abs/2607.07436,[2607.07436] The Blind Curator: How a Biased Judge Silently Disables Skill Retirement in Self-Evolving Agents,"A self-evolving agent retires its bad skills by watching them fail, so what happens when the judge cannot see the failures? Skill retirement is the structural constraint that keeps a growing library from drifting below the no-skill baseline, but its guarantee assumes an unbiased reward, which is false for the LLM judges that reference-free tasks force upon us. We show that a biased judge does not merely add noise; it \emph{silently switches off the curator}. We make this precise with a corrupted-reward analysis and, isolating the causal channel by injecting corruption on top of a deterministic reward, a behavioral study on a reference-free report-writing testbed with a code-generation cross-check. Symmetric noise leaves retirement intact, but \emph{false-pass} bias (failures slipping through as passes) disables contribution-based retirement past a sharp threshold that no amount of data can cross. Separating genuine retirement from cap-eviction churn shows this \emph{mechanism} failure is universal, holding across domains and failure rates and sparing only near-zero-false-pass, verifier-like graders. The downstream \emph{outcome}, though, is regime-dependent: eval quality degrades only where the same corruption also starves skill synthesis, and otherwise holds steady, so the disabled curator is \emph{silent}, surfacing in no aggregate metric. The contribution is a behavioral safety result, not a performance one. A cheap defect-injection audit then tells an operator, before deployment, which side of the threshold their judge occupies.",Xing Zhang; Yanwei Cui; Guanghui Wang; Ziyuan Li; Wei Qiu; Bing Zhu; Peiyang He,2026-07-08,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,2607.07436,2026-07-17T17:58:18+00:00 -ale-0516,"Critiques, Risks, And Limitations",critiques-risks-and-limitations,Paper,πŸ“„,Do LLM-Generated Skills Make Better AI Data Scientists? A Component Ablation Across Data-Science Workflows,https://arxiv.org/abs/2607.07504,external,arxiv.org,"Negative result for low-curation skill libraries: across four data-science lifecycle stages (56 tasks), fully LLM-generated skill files show no reliable improvement over plain task prompting, and component ablations find no skill part that helps either (all p > 0.396). Useful counterweight to the skill-generation enthusiasm in self-evolving agent stacks, curation still matters.","Negative result for low-curation skill libraries: across four data-science lifecycle stages (56 tasks), fully LLM-generated skill files show no reliable improvement over plain task prompting, and component ablations find no skill part that helps either (all p > 0.396). Useful counterweight to the skill-generation enthusiasm in self-evolving agent stacks, curation still matters.","Negative result for low-curation skill libraries: across four data-science lifecycle stages (56 tasks), fully LLM-generated skill files show no reliable improvement over plain task prompting, and component ablations find no skill part that helps either (all p > 0.396). Useful counterweight to the skill-generation enthusiasm in self-evolving agent stacks, curation still matters.","Keeps adoption grounded in known failure modes, economics, and operational limits. Negative result for low-curation skill libraries: across four data-science lifecycle stages (56 tasks), fully LLM-generated skill files show no reliable improvement over plain task prompting, and component ablations find no skill part that helps either (all p > 0.396). Useful counterweight to the skill-generation enthusiasm in self-evolving agent stacks, curation still matters.",Use Do LLM-Generated Skills Make Better AI Data Scientists? A Component Ablation Across Data-Science Workflows to bound risk before recurring or unattended execution.,Research source arXiv:2607.07504; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1192,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1192,,Govern,govern,"Bound permissions, cost, failure, and escalation.",budget;escalation;exit,researcher;evaluator;operator;security,research-preprint,ok,https://arxiv.org/abs/2607.07504,[2607.07504] Do LLM-Generated Skills Make Better AI Data Scientists? A Component Ablation Across Data-Science Workflows,"Product data scientists often ask LLM-based agents to help with recurring execution tasks such as cleaning data, writing SQL, choosing statistical tests, and formatting results. Reusable skill files are meant to avoid prompting from scratch by packaging guidance for a task family. Expert-written skills can encode high-quality guidance, but writing and maintaining them across many data-science task families creates a manual bottleneck. We ask whether LLM-generated skills offer a useful low-curation alternative: do they improve performance over the task prompt alone? We test this question across four lifecycle stages: data preparation, data extraction, statistical analysis, and reporting, using one generated skill per stage. We find no reliable improvement from full generated skills over No-Skill prompting. We then ask whether any part of the skill is useful by ablating different skill components. The main ablation covers 56 tasks, nine model configurations, and three providers, yielding 7,560 runs. Compared with prompting using the task alone, neither the full generated skill nor any ablated skill variant significantly improves performance; all p-values are at least 0.396, and the total spread across variants is only 1.2 pp. A supplemental token-matched control adds 1,512 runs and finds that Full skills perform similarly to task-irrelevant skill-formatted content. The results caution against using one LLM-generated skill per data-science workflow as a default single-shot prompting strategy.",Wei-Jung Huang,2026-07-08,2026,KDD 2026 Workshop on AI Data Scientist,arXiv,,KDD 2026 Workshop on AI Data Scientist,cs.AI,arxiv-api,,,,,,,2607.07504,2026-07-17T17:58:18+00:00 +ale-0516,"Critiques, Risks, And Limitations",critiques-risks-and-limitations,Paper,πŸ“„,Do LLM-Generated Skills Make Better AI Data Scientists? A Component Ablation Across Data-Science Workflows,https://arxiv.org/abs/2607.07504,external,arxiv.org,"Negative result for low-curation skill libraries: across four data-science lifecycle stages (56 tasks), fully LLM-generated skill files show no reliable improvement over plain task prompting, and component ablations find no skill part that helps either (all p > 0.396). Useful counterweight to the skill-generation enthusiasm in self-evolving agent stacks, curation still matters.","Negative result for low-curation skill libraries: across four data-science lifecycle stages (56 tasks), fully LLM-generated skill files show no reliable improvement over plain task prompting, and component ablations find no skill part that helps either (all p > 0.396). Useful counterweight to the skill-generation enthusiasm in self-evolving agent stacks, curation still matters.","Negative result for low-curation skill libraries: across four data-science lifecycle stages (56 tasks), fully LLM-generated skill files show no reliable improvement over plain task prompting, and component ablations find no skill part that helps either (all p > 0.396). Useful counterweight to the skill-generation enthusiasm in self-evolving agent stacks, curation still matters.","Keeps adoption grounded in known failure modes, economics, and operational limits. Negative result for low-curation skill libraries: across four data-science lifecycle stages (56 tasks), fully LLM-generated skill files show no reliable improvement over plain task prompting, and component ablations find no skill part that helps either (all p > 0.396). Useful counterweight to the skill-generation enthusiasm in self-evolving agent stacks, curation still matters.",Use Do LLM-Generated Skills Make Better AI Data Scientists? A Component Ablation Across Data-Science Workflows to bound risk before recurring or unattended execution.,Research source arXiv:2607.07504; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1192,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1192,,Govern,govern,"Bound permissions, cost, failure, and escalation.",budget;escalation;exit,researcher;evaluator;operator;security,research-paper,ok,https://arxiv.org/abs/2607.07504,[2607.07504] Do LLM-Generated Skills Make Better AI Data Scientists? A Component Ablation Across Data-Science Workflows,"Product data scientists often ask LLM-based agents to help with recurring execution tasks such as cleaning data, writing SQL, choosing statistical tests, and formatting results. Reusable skill files are meant to avoid prompting from scratch by packaging guidance for a task family. Expert-written skills can encode high-quality guidance, but writing and maintaining them across many data-science task families creates a manual bottleneck. We ask whether LLM-generated skills offer a useful low-curation alternative: do they improve performance over the task prompt alone? We test this question across four lifecycle stages: data preparation, data extraction, statistical analysis, and reporting, using one generated skill per stage. We find no reliable improvement from full generated skills over No-Skill prompting. We then ask whether any part of the skill is useful by ablating different skill components. The main ablation covers 56 tasks, nine model configurations, and three providers, yielding 7,560 runs. Compared with prompting using the task alone, neither the full generated skill nor any ablated skill variant significantly improves performance; all p-values are at least 0.396, and the total spread across variants is only 1.2 pp. A supplemental token-matched control adds 1,512 runs and finds that Full skills perform similarly to task-irrelevant skill-formatted content. The results caution against using one LLM-generated skill per data-science workflow as a default single-shot prompting strategy.",Wei-Jung Huang,2026,2026,KDD Workshop on AI Data Scientist,ACM SIGKDD,,Accepted at KDD Workshop on AI Data Scientist; the linked arXiv record is the available paper version.,cs.AI,Current arXiv acceptance note and official workshop page,,,,,,,2607.07504,2026-07-17T17:58:18+00:00 ale-0517,"Critiques, Risks, And Limitations",critiques-risks-and-limitations,Paper,πŸ“„,The Verification Horizon: No Silver Bullet for Coding Agent Rewards,https://arxiv.org/abs/2606.26300,external,arxiv.org,"Position paper arguing verification has become harder than generation for coding agents: every verifier is only a proxy for underspecified human intent, so reward design faces a horizon that no single verification mechanism crosses.","Position paper arguing verification has become harder than generation for coding agents: every verifier is only a proxy for underspecified human intent, so reward design faces a horizon that no single verification mechanism crosses.","Position paper arguing verification has become harder than generation for coding agents: every verifier is only a proxy for underspecified human intent, so reward design faces a horizon that no single verification mechanism crosses.","Verification is promoted from a final check to a loop-control signal. Position paper arguing verification has become harder than generation for coding agents: every verifier is only a proxy for underspecified human intent, so reward design faces a horizon that no single verification mechanism crosses.",Use The Verification Horizon: No Silver Bullet for Coding Agent Rewards to bound risk before recurring or unattended execution.,Research source arXiv:2606.26300; inspect its method and evaluation before treating results as production evidence.,medium,README.md,1193,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1193,,Govern,govern,"Bound permissions, cost, failure, and escalation.",verification;escalation,researcher;evaluator;operator;security,research-preprint,ok,https://arxiv.org/abs/2606.26300,[2606.26300] The Verification Horizon: No Silver Bullet for Coding Agent Rewards,"A classical intuition holds that verifying a solution is easier than producing one. For today's coding agents, this intuition is being inverted: as foundation models develop stronger reasoning capabilities and engineering harnesses grow more sophisticated, generating complex candidate solutions is no longer difficult -- reliably verifying them has become the harder problem. Every verifier we can build is only a proxy for human intent, never the intent itself. This makes verification subject to a twofold difficulty: first, intent is underspecified by nature, making it inherently hard to faithfully check whether it has been fulfilled; second, during model training, optimization widens the gap between proxy and intent -- manifesting as reward hacking or signal saturation. To address this, we characterize the quality of verification signals along three dimensions -- scalability, faithfulness, and robustness -- and argue that achieving all three simultaneously is the central challenge. We further study four reward constructions: a test verifier for general coding tasks, a rubric verifier for frontend tasks, the user as verifier for real-world agent tasks, and an automated agent verifier for long-horizon tasks. Across different task types and policy capability levels, we conduct in-depth analysis and experiments on the core challenges of reward design and how to more effectively leverage reward signals. Experiments show that targeted verification design can effectively suppress reward hacking, improve task completion quality, and achieve significant gains across multiple internal and public benchmarks. These experiences collectively point to a core observation: no fixed reward function can remain effective as policy capability continues to grow; and verification must co-evolve with the generator.",Binghai Wang; Chenlong Zhang; Dayiheng Liu; Jiajun Zhang; Jiawei Chen; Mingze Li; Mouxiang Chen; Rongyao Fang; Siyuan Zhang; Xuwu Wang; Yuheng Jing; Zeyao Ma; Zeyu Cui,2026-06-24,2026,arXiv,arXiv,,Authors are listed alphabetically by their first names,cs.AI,arxiv-api,,,,,,,2606.26300,2026-07-17T17:58:18+00:00 ale-0518,"Critiques, Risks, And Limitations",critiques-risks-and-limitations,Critique,⚠️,Write Code Like a Human Will Maintain It,https://unstack.io/write-code-like-a-human-will-maintain-it,external,unstack.io,"Argues that agent-driven codebases create a compounding feedback loop where every merged shortcut becomes training signal for the next generation of changes, so code quality standards matter more, not less, under automation.","Argues that agent-driven codebases create a compounding feedback loop where every merged shortcut becomes training signal for the next generation of changes, so code quality standards matter more, not less, under automation.","Argues that agent-driven codebases create a compounding feedback loop where every merged shortcut becomes training signal for the next generation of changes, so code quality standards matter more, not less, under automation.","Keeps adoption grounded in known failure modes, economics, and operational limits. Argues that agent-driven codebases create a compounding feedback loop where every merged shortcut becomes training signal for the next generation of changes, so code quality standards matter more, not less, under automation.",Use Write Code Like a Human Will Maintain It to bound risk before recurring or unattended execution.,"Contextual source from unstack.io; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,1194,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1194,,Govern,govern,"Bound permissions, cost, failure, and escalation.",escalation,operator;security,risk-analysis,ok,https://unstack.io/write-code-like-a-human-will-maintain-it,Write code like a human will maintain it,"One of the best things about LLMs is that they'll write code for you, all day long. Who cares about DRY? You don't have to be the one updating the same long con...",,2026-07-10,2026,,Unstack,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00 ale-0519,"Critiques, Risks, And Limitations",critiques-risks-and-limitations,Blog,πŸ“,Claude Code Sends 33k Tokens Before Reading the Prompt,https://systima.ai/blog/claude-code-vs-opencode-token-overhead,external,systima.ai,"July 12, 2026 proxy-interception study of per-turn harness overhead: Claude Code sends ~33k tokens of scaffolding before user input versus OpenCode's ~7k (a 4.7x gap that narrows to 3.3x on newer models), mid-session cache-block rewrites produce up to 54x more cache-write tokens on identical tasks, a 72KB instruction file adds ~20k tokens per request, five MCP servers add 5-7k more, and subagent delegation alone multiplied total cost 4.2x. Directly quantifies the per-iteration economics that compound across recurring loops, with transparent methodology of identical-outcome tasks and a logging proxy capturing exact request payloads.","July 12, 2026 proxy-interception study of per-turn harness overhead: Claude Code sends ~33k tokens of scaffolding before user input versus OpenCode's ~7k (a 4.7x gap that narrows to 3.3x on newer models), mid-session cache-block rewrites produce up to 54x more cache-write tokens on identical tasks, a 72KB instruction file adds ~20k tokens per request, five MCP servers add 5-7k more, and subagent delegation alone multiplied total cost 4.2x. Directly quantifies the per-iteration economics that compound across recurring loops, with transparent methodology of identical-outcome tasks and a logging proxy capturing exact request payloads.","July 12, 2026 proxy-interception study of per-turn harness overhead: Claude Code sends ~33k tokens of scaffolding before user input versus OpenCode's ~7k (a 4.7x gap that narrows to 3.3x on newer models), mid-session cache-block rewrites produce up to 54x more cache-write tokens on identical tasks, a 72KB instruction file adds ~20k tokens per request, five MCP servers add 5-7k more, and subagent delegation alone multiplied total cost 4.2x. Directly quantifies the per-iteration economics that compound across recurring loops, with transparent methodology of identical-outcome tasks and a logging proxy capturing exact request payloads.","The work separates roles across agents, verifiers, or orchestration layers. July 12, 2026 proxy-interception study of per-turn harness overhead: Claude Code sends ~33k tokens of scaffolding before user input versus OpenCode's ~7k (a 4.7x gap that narrows to 3.3x on newer models), mid-session cache-block rewrites produce up to 54x more cache-write tokens on identical tasks, a 72KB instruction file adds ~20k tokens per request, five MCP servers add 5-7k more, and subagent delegation alone multiplied total cost 4.2x. Directly quantifies the per-iteration economics that compound across recurring loops, with transparent methodology of identical-outcome tasks and a logging proxy capturing exact request payloads.",Use Claude Code Sends 33k Tokens Before Reading the Prompt to bound risk before recurring or unattended execution.,"Contextual source from systima.ai; useful for practice signals or boundary conditions, not independent validation.",contextual,README.md,1195,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md#L1195,,Govern,govern,"Bound permissions, cost, failure, and escalation.",delegation;budget,operator;security,practitioner-analysis,ok,https://systima.ai/blog/claude-code-vs-opencode-token-overhead,Claude Code Sends 4.7x More Tokens Than OpenCode Before Reading Your Prompt | Systima Blog,"Claude Code vs OpenCode token overhead measured at the API boundary. Out-of-the-box baselines, instruction file weight, MCP schema tax, subagent multipliers, and cache-write behaviour.",Systima,2026-07-12,2026,,Systima,,,,html-meta,,,,,,,,2026-07-17T17:58:18+00:00