row_id,title,url,url_kind,domain,audit_status,http_status,final_url,canonical_url,content_type,source_title,source_description,authors,publication_date,publication_year,publication_venue,publisher,doi,publication_note,primary_category,metadata_source,github_repo,github_stars,github_forks,github_open_issues,github_description,github_license,github_created_at,github_updated_at,arxiv_id,error,retrieved_at
ale-0001,Canonical Definition,DEFINITION.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/DEFINITION.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/DEFINITION.md,,Canonical Definition,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0002,Loop Engineering Manifesto,MANIFESTO.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/MANIFESTO.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/MANIFESTO.md,,Loop Engineering Manifesto,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0003,Loop Engineering Taxonomy,TAXONOMY.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/TAXONOMY.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/TAXONOMY.md,,Loop Engineering Taxonomy,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0004,Loop Engineering Anti-Patterns,ANTI-PATTERNS.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/ANTI-PATTERNS.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/ANTI-PATTERNS.md,,Loop Engineering Anti-Patterns,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0005,Comparison Guide,COMPARISON.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/COMPARISON.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/COMPARISON.md,,Comparison Guide,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0006,Sourced Signals And Quotes,QUOTES.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/QUOTES.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/QUOTES.md,,Sourced Signals And Quotes,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0007,Outreach Kit,meta/OUTREACH.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/meta/OUTREACH.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/meta/OUTREACH.md,,Outreach Kit,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0008,Loop Engineering by Addy Osmani,https://addyosmani.com/blog/loop-engineering/,external,addyosmani.com,ok,200,https://addyosmani.com/blog/loop-engineering/,https://addyosmani.com/blog/loop-engineering/,text/html; charset=UTF-8,AddyOsmani.com - Loop Engineering,You don't really need to be good at prompting anymore. The thing to get good at is the loop that does the prompting for you. It's five building blocks plus s...,Addy Osmani,,,,addyosmani.com,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0009,Peter Steinberger on designing loops,https://x.com/steipete/status/2063697162748260627,external,x.com,ok,200,https://x.com/steipete/status/2063697162748260627,https://x.com/steipete/status/2063697162748260627,text/html; charset=UTF-8,"Peter Steinberger 🦞 on X: ""Here’s your monthly reminder that you shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents."" / X",Here’s your monthly reminder that you shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents.,,2026-06-07,2026,,X (formerly Twitter),,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0010,Boris Cherny: five tips for running Opus autonomously for hours or days,https://x.com/bcherny/status/2063792263067754658,external,x.com,ok,200,https://x.com/bcherny/status/2063792263067754658,https://x.com/bcherny/status/2063792263067754658,text/html; charset=UTF-8,"Boris Cherny on X: ""Seeing a number of benchmarks showing Opus is the best model for long-running work. Five tips for running Opus autonomously for hours/days: 1. Use auto mode for permissions, so Claude doesn’t ask for approval 2. Use dynamic workflows, to have Claude orchestrate"" / X","Seeing a number of benchmarks showing Opus is the best model for long-running work. Five tips for running Opus autonomously for hours/days: 1. Use auto mode for permissions, so Claude doesn’t ask for approval 2. Use dynamic workflows, to have Claude orchestrate",,2026-06-08,2026,,X (formerly Twitter),,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0011,Loop Engineering by Cobus Greyling,https://cobusgreyling.substack.com/p/loop-engineering,external,cobusgreyling.substack.com,ok,200,https://cobusgreyling.substack.com/p/loop-engineering,https://cobusgreyling.substack.com/p/loop-engineering,text/html; charset=utf-8,Loop Engineering,The core of Loop Engineering,Cobus Greyling,,,,Substack,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0012,Stop Prompting. Design the Loop.,https://www.pulumi.com/blog/stop-prompting-design-the-loop/,external,www.pulumi.com,ok,200,https://www.pulumi.com/blog/stop-prompting-design-the-loop/,https://www.pulumi.com/blog/stop-prompting-design-the-loop/,text/html; charset=utf-8,Stop Prompting. Design the Loop. | Pulumi Blog,"The unit of work moved from the prompt to the loop. The five pieces of loop engineering, the memory that makes it compound, and what it won't do for you.",Engin Diri,2026-06-09,2026,,pulumi,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0013,"Writing Loops, Not Prompts, Explained",https://rico.codes/loops-not-prompts,external,rico.codes,ok,200,https://rico.codes/loops-not-prompts,https://rico.codes/loops-not-prompts,text/html; charset=utf-8,"Writing Loops, Not Prompts, Explained | rico.codes","Loop engineering is not about abandoning prompts. It is about moving repeated steering work into verifiable systems so attention can stay on judgment, review, and taste.",,,,,rico.codes,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0014,Loop Engineering: A Guide for Engineers and Practitioners,https://medium.com/@adnanmasood/loop-engineering-a-guide-for-engineers-and-practitioners-893bb65ea943,external,medium.com,ok,200,https://medium.com/@adnanmasood/loop-engineering-a-guide-for-engineers-and-practitioners-893bb65ea943,https://medium.com/@adnanmasood/loop-engineering-a-guide-for-engineers-and-practitioners-893bb65ea943,text/html; charset=utf-8,"Medium Loop Engineering: A Guide for Engineers and Practitioners | by Adnan Masood, PhD. | Jun, 2026 | Medium","Loop engineering: designing the control system that prompts, verifies, and stops AI agents in production. A field guide for engineers.","Adnan Masood, PhD.",2026-06-24,2026,,Medium,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0015,"Loop Engineering: When Generation Gets Cheap, Judgment Gets Expensive",https://sderosiaux.substack.com/p/loop-engineering-cheap-generation,external,sderosiaux.substack.com,ok,200,https://sderosiaux.substack.com/p/loop-engineering-cheap-generation,https://sderosiaux.substack.com/p/loop-engineering-cheap-generation,text/html; charset=utf-8,"Loop Engineering: When Generation Gets Cheap, Judgment Gets Expensive","Agentic loops make code, plans, and PRs abundant. The scarce part is knowing what is right.",Stephane Derosiaux,,,,Substack,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0016,Andrew Ng on Loop Engineering and the Three Loops of AI-Native Product Development,https://x.com/AndrewYNg/status/2071988145667928442,external,x.com,ok,200,https://x.com/AndrewYNg/status/2071988145667928442,https://x.com/AndrewYNg/status/2071988145667928442,text/html; charset=UTF-8,"Andrew Ng on X: ""“Loop engineering” is a hot buzzphrase after mentions of it by Boris Cherny (Claude Code’s creator) and Peter Steinberger (OpenClaw's creator) went viral on social media. Loops are now a key part of how we get AI agents to iterate at length to build software. In this letter, I’d https://t.co/bhuRw8lrFC"" / X","“Loop engineering” is a hot buzzphrase after mentions of it by Boris Cherny (Claude Code’s creator) and Peter Steinberger (OpenClaw's creator) went viral on social media. Loops are now a key part of how we get AI agents to iterate at length to build software. In this letter, I’d",,2026-06-30,2026,,X (formerly Twitter),,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0017,From Prompting Agents to Loop Engineering,https://x.com/omarsar0/status/2068008743153832264,external,x.com,ok,200,https://x.com/omarsar0/status/2068008743153832264,https://x.com/omarsar0/status/2068008743153832264,text/html; charset=UTF-8,"elvis on X: ""https://t.co/d8LgEwfVH6"" / X",https://t.co/d8LgEwfVH6,,2026-06-19,2026,,X (formerly Twitter),,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0018,My Lord! AI Programming Undergoes Another Major Shift,https://eu.36kr.com/en/p/3844224911346184,external,eu.36kr.com,ok,200,https://eu.36kr.com/en/p/3844224911346184,https://eu.36kr.com/en/p/3844224911346184,text/html; charset=utf-8,My Lord! AI Programming Undergoes Another Major Shift: Claude Code Father & Lobster Founder Endorse New Paradigm - Could It Kill Prompt Engineering?,Stop writing prompts for programming agents now.,,,,,eu.36kr.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0019,The Anthropic leader who built Claude Code ditched prompting - now he writes loops,https://thenewstack.io/loop-engineering/,external,thenewstack.io,ok,200,https://thenewstack.io/loop-engineering/,https://thenewstack.io/loop-engineering/,text/html; charset=UTF-8,The Anthropic leader who built Claude Code says he ditched prompting — now he just writes loops. - The New Stack,Loop engineering — the practice of designing automated agent workflows instead of prompting manually — is reshaping how developers use Claude Code and OpenAI Codex in 2026.,Janakiram MSV,2026-06-10,2026,,The New Stack,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0020,Engineering for Agents That Never Sleep,https://nader.substack.com/p/engineering-for-agents-that-never,external,nader.substack.com,ok,200,https://nader.substack.com/p/engineering-for-agents-that-never,https://nader.substack.com/p/engineering-for-agents-that-never,text/html; charset=utf-8,Engineering for Agents That Never Sleep - by Nader Dabit,Originally posted on X.,Nader Dabit,,,,Substack,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0021,Loop Engineering Orange Book,https://github.com/alchaincyf/loop-engineering-orange-book,external,github.com,ok,200,https://github.com/alchaincyf/loop-engineering-orange-book,https://github.com/alchaincyf/loop-engineering-orange-book,text/html; charset=utf-8,GitHub - alchaincyf/loop-engineering-orange-book: 别再问我什么是 Loop Engineering — 橙皮书系列。A plain-language guide to loop engineering (中文 + English PDF). Free. · GitHub,别再问我什么是 Loop Engineering — 橙皮书系列。A plain-language guide to loop engineering (中文 + English PDF). Free. - alchaincyf/loop-engineering-orange-book,,2026-06-15,2026,alchaincyf/loop-engineering-orange-book,GitHub,,,,github-api,alchaincyf/loop-engineering-orange-book,1025,99,0,别再问我什么是 Loop Engineering — 橙皮书系列。A plain-language guide to loop engineering (中文 + English PDF). Free.,NOASSERTION,2026-06-15T05:27:07Z,2026-07-18T07:01:35Z,,,2026-07-18T08:16:45+00:00
ale-0022,How I AI: How to Write AI Agent Loops in Claude Code and Codex,https://www.lennysnewsletter.com/p/how-i-ai-how-to-write-ai-agent-loops,external,www.lennysnewsletter.com,ok,200,https://www.lennysnewsletter.com/p/how-i-ai-how-to-write-ai-agent-loops,https://www.lennysnewsletter.com/p/how-i-ai-how-to-write-ai-agent-loops,text/html; charset=utf-8,🎙️ How I AI: How to write AI agent loops in Claude Code and Codex + How Claude Mythos found a 15-year-old bug in Mozilla Firefox | Brian Grinstead,"Your weekly listens from How I AI, part of the Lenny’s Podcast Network",Lenny Rachitsky,,,,lennysnewsletter.com,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0023,"Proof-or-Stop: Don't Trust the Agent, Trust the Evidence -- Loop Engineering for Verifiable Evidence-Gated Lifecycle Control",https://arxiv.org/abs/2607.14890,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14890,https://arxiv.org/abs/2607.14890,text/html; charset=utf-8,"[2607.14890] Proof-or-Stop: Don't Trust the Agent, Trust the Evidence -- Loop Engineering for Verifiable Evidence-Gated Lifecycle Control","Autonomous coding agents increasingly execute multi-step software work, but lifecycle states such as reviewed, tested, DONE, and ready-to-merge remain claims unless supported by current evidence. We present Proof-or-Stop Lifecycle Control, a method that permits lifecycle transitions only when fresh, tracked-source-state-bound, mechanically verifiable evidence satisfies the relevant gate. The method treats agent outputs as claims rather than lifecycle state, and uses proof operationally to mean gate-admissible evidence under a stated trust model, not semantic program correctness. We evaluate an open-source implementation through mechanism tests, a powered control-policy ablation, and operated self-application evidence. The unattended-loop engine passed 10 of 10 scenarios with zero false-DONE, and local-key receipt bundles rejected 18 tamper classes with zero false accepts. In a 9,240-cell ablation, the pre-registered A4 versus A2-prime comparison reduced visible-pass/hidden-fail amplification from 31 of 1,800 injected cells under a compute-budgeted naive loop to 2 of 1,800 under the gated loop, a 1.6 percentage-point improvement in not-amplified rate with a 95 percent confidence interval of [0.8, 2.5]. A near-compute A3 versus A4 comparison, 14 of 1,800 versus 2 of 1,800, indicates that the gain is associated with enforcing review as a lifecycle gate rather than merely adding a reviewer. The self-application corpus contains 565 stories and 1,007 review findings, with 94.8 percent resolved, plus a 68-row high/critical cross-vendor exhibit. These results support Proof-or-Stop as a model-agnostic, host-neutral control layer for deciding which autonomous-agent claims a lifecycle may act on. The evaluation is limited to one model family, 24 ablation tasks, and a self-hosted corpus.",Jek Huang; Jeffery Hsia; Jiayi Sun; Freddie Shi; Wei Huang; Ian H. White,2026-07-16,2026,arXiv,arXiv,,"48 pages, 10 figures, 29 numbered tables. Preprint v1",cs.AI,arxiv-api,,,,,,,,,2607.14890,,2026-07-18T08:16:45+00:00
ale-0024,PR babysitter,patterns/pr-babysitter.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/pr-babysitter.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/pr-babysitter.md,,PR babysitter,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0025,CI repair loop,patterns/ci-repair-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/ci-repair-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/ci-repair-loop.md,,CI repair loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0026,Docs drift collector,patterns/docs-drift-collector.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/docs-drift-collector.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/docs-drift-collector.md,,Docs drift collector,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0027,Deploy verifier,patterns/deploy-verifier.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/deploy-verifier.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/deploy-verifier.md,,Deploy verifier,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0028,Feedback clusterer,patterns/feedback-clusterer.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/feedback-clusterer.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/feedback-clusterer.md,,Feedback clusterer,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0029,Dependency triage loop,patterns/dependency-triage-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/dependency-triage-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/dependency-triage-loop.md,,Dependency triage loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0030,Evaluation regression loop,patterns/evaluation-regression-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/evaluation-regression-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/evaluation-regression-loop.md,,Evaluation regression loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0031,Benchmark optimization loop,patterns/benchmark-optimization-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/benchmark-optimization-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/benchmark-optimization-loop.md,,Benchmark optimization loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0032,Security review loop,patterns/security-review-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/security-review-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/security-review-loop.md,,Security review loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0033,Adversarial red-team loop,patterns/adversarial-red-team-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/adversarial-red-team-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/adversarial-red-team-loop.md,,Adversarial red-team loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0034,Accessibility regression loop,patterns/accessibility-regression-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/accessibility-regression-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/accessibility-regression-loop.md,,Accessibility regression loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0035,Cost-control loop,patterns/cost-control-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/cost-control-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/cost-control-loop.md,,Cost-control loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0036,Performance regression loop,patterns/performance-regression-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/performance-regression-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/performance-regression-loop.md,,Performance regression loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0037,Bug hunting loop,patterns/bug-hunting-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/bug-hunting-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/bug-hunting-loop.md,,Bug hunting loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0038,Enterprise approval loop,patterns/enterprise-approval-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/enterprise-approval-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/enterprise-approval-loop.md,,Enterprise approval loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0039,Incident response loop,patterns/incident-response-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/incident-response-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/incident-response-loop.md,,Incident response loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0040,Data-quality loop,patterns/data-quality-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/data-quality-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/data-quality-loop.md,,Data-quality loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0041,Knowledge freshness loop,patterns/knowledge-freshness-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/knowledge-freshness-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/knowledge-freshness-loop.md,,Knowledge freshness loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0042,Release-note loop,patterns/release-note-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/release-note-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/release-note-loop.md,,Release-note loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0043,Model-routing loop,patterns/model-routing-loop.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/model-routing-loop.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/model-routing-loop.md,,Model-routing loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0044,Scheduled tasks - ChatGPT Learn,https://learn.chatgpt.com/docs/automations?surface=app,external,learn.chatgpt.com,ok,200,https://learn.chatgpt.com/docs/automations?surface=app,https://learn.chatgpt.com/docs/automations?surface=app,text/html; charset=utf-8,Scheduled tasks | ChatGPT Learn,Schedule recurring tasks in ChatGPT,,,,,ChatGPT Learn,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0045,Follow a goal - ChatGPT Learn,https://learn.chatgpt.com/use-cases/follow-goals,external,learn.chatgpt.com,ok,200,https://learn.chatgpt.com/use-cases/follow-goals,https://learn.chatgpt.com/use-cases/follow-goals,text/html; charset=utf-8,Follow a goal | ChatGPT use cases,Use `/goal` when a task needs Codex to keep working across turns toward a verifiable stopping condition.,,,,,ChatGPT Learn,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0046,Git worktrees - ChatGPT Learn,https://learn.chatgpt.com/docs/environments/git-worktrees,external,learn.chatgpt.com,ok,200,https://learn.chatgpt.com/docs/environments/git-worktrees,https://learn.chatgpt.com/docs/environments/git-worktrees,text/html; charset=utf-8,Worktrees | ChatGPT Learn,Use Git worktrees in Codex in the ChatGPT desktop app to run chats in parallel,,,,,ChatGPT Learn,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0047,Prompting - ChatGPT Learn,https://learn.chatgpt.com/docs/prompting,external,learn.chatgpt.com,ok,200,https://learn.chatgpt.com/docs/prompting,https://learn.chatgpt.com/docs/prompting,text/html; charset=utf-8,Prompting | ChatGPT Learn,"Write useful prompts for Chat mode, Work mode, and Codex",,,,,ChatGPT Learn,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0048,Customization overview - ChatGPT Learn,https://learn.chatgpt.com/docs/customization/overview,external,learn.chatgpt.com,ok,200,https://learn.chatgpt.com/docs/customization/overview,https://learn.chatgpt.com/docs/customization/overview,text/html; charset=utf-8,Customization | ChatGPT Learn,"How to customize Codex with project guidance, skills, MCP, and subagents",,,,,ChatGPT Learn,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0049,Build skills - ChatGPT Learn,https://learn.chatgpt.com/docs/build-skills,external,learn.chatgpt.com,ok,200,https://learn.chatgpt.com/docs/build-skills,https://learn.chatgpt.com/docs/build-skills,text/html; charset=utf-8,Build skills | ChatGPT Learn,Give Codex new capabilities and expertise,,,,,ChatGPT Learn,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0050,Plugins - ChatGPT Learn,https://learn.chatgpt.com/docs/plugins,external,learn.chatgpt.com,ok,200,https://learn.chatgpt.com/docs/plugins,https://learn.chatgpt.com/docs/plugins,text/html; charset=utf-8,Plugins | ChatGPT Learn,"Browse, install, and use plugins on supported ChatGPT and Codex surfaces",,,,,ChatGPT Learn,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0051,dotskills,https://github.com/vincentkoc/dotskills,external,github.com,ok,200,https://github.com/vincentkoc/dotskills,https://github.com/vincentkoc/dotskills,text/html; charset=utf-8,"GitHub - vincentkoc/dotskills: 🐙 A curated set of Codex and OpenClaw skills for workflow automation, technical debugging, and agent-assisted development patterns. · GitHub","🐙 A curated set of Codex and OpenClaw skills for workflow automation, technical debugging, and agent-assisted development patterns. - vincentkoc/dotskills",,2026-02-17,2026,vincentkoc/dotskills,GitHub,,,,github-api,vincentkoc/dotskills,97,9,8,"🐙 A curated set of Codex and OpenClaw skills for workflow automation, technical debugging, and agent-assisted development patterns.",MIT,2026-02-17T05:08:29Z,2026-07-17T14:05:09Z,,,2026-07-18T08:16:45+00:00
ale-0052,Developer commands - ChatGPT Learn,https://learn.chatgpt.com/docs/developer-commands?surface=cli,external,learn.chatgpt.com,ok,200,https://learn.chatgpt.com/docs/developer-commands?surface=cli,https://learn.chatgpt.com/docs/developer-commands?surface=cli,text/html; charset=utf-8,Developer commands | ChatGPT Learn,Reference for commands and slash commands in Codex developer surfaces,,,,,ChatGPT Learn,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0053,Autonomous Loops,https://claudecodeguide.dev/docs/patterns/autonomous-loops,external,claudecodeguide.dev,ok,200,https://claudecodeguide.dev/docs/patterns/autonomous-loops,https://claudecodeguide.dev/docs/patterns/autonomous-loops,text/html; charset=utf-8,Claude Code Autonomous Loops | Claude Code Guide,"Point Claude Code at a problem, walk away, come back to a green build. Task templates, kill switches, and why boundaries matter more than anything else.",,,,,claudecodeguide.dev,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0054,Claude Code Glossary,https://code.claude.com/docs/en/glossary.md,external,code.claude.com,ok,200,https://code.claude.com/docs/en/glossary.md,https://code.claude.com/docs/en/glossary.md,text/markdown; charset=utf-8,,,,,,,Anthropic,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0055,Keep Claude working toward a goal,https://code.claude.com/docs/en/goal,external,code.claude.com,ok,200,https://code.claude.com/docs/en/goal,https://code.claude.com/docs/en/goal,text/html; charset=utf-8,Keep Claude working toward a goal - Claude Code Docs,Set a completion condition with /goal and Claude keeps working across turns until the condition is met.,,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0056,Run prompts on a schedule,https://code.claude.com/docs/en/scheduled-tasks,external,code.claude.com,ok,200,https://code.claude.com/docs/en/scheduled-tasks,https://code.claude.com/docs/en/scheduled-tasks,text/html; charset=utf-8,Run prompts on a schedule - Claude Code Docs,"Use /loop and the cron scheduling tools to run prompts repeatedly, poll for status, or set one-time reminders within a Claude Code session.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0057,Automate work with routines,https://code.claude.com/docs/en/routines,external,code.claude.com,ok,200,https://code.claude.com/docs/en/routines,https://code.claude.com/docs/en/routines,text/html; charset=utf-8,Automate work with routines - Claude Code Docs,"Put Claude Code on autopilot. Define routines that run on a schedule, trigger on API calls, or react to GitHub events from Anthropic-managed cloud infrastructure.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0058,Desktop scheduled tasks,https://code.claude.com/docs/en/desktop-scheduled-tasks,external,code.claude.com,ok,200,https://code.claude.com/docs/en/desktop-scheduled-tasks,https://code.claude.com/docs/en/desktop-scheduled-tasks,text/html; charset=utf-8,Schedule recurring tasks in Claude Code Desktop - Claude Code Docs,"Set up scheduled tasks in Claude Code Desktop to run Claude automatically on a recurring basis for daily code reviews, dependency audits, or morning briefings.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0059,Run parallel sessions with worktrees,https://code.claude.com/docs/en/worktrees,external,code.claude.com,ok,200,https://code.claude.com/docs/en/worktrees,https://code.claude.com/docs/en/worktrees,text/html; charset=utf-8,Run parallel sessions with worktrees - Claude Code Docs,"Isolate parallel Claude Code sessions in separate git worktrees so changes don't collide. Covers the --worktree flag, subagent isolation, .worktreeinclude, cleanup, and non-git VCS hooks.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0060,Automate actions with hooks,https://code.claude.com/docs/en/hooks-guide,external,code.claude.com,ok,200,https://code.claude.com/docs/en/hooks-guide,https://code.claude.com/docs/en/hooks-guide,text/html; charset=utf-8,Automate actions with hooks - Claude Code Docs,"Run shell commands automatically when Claude Code edits files, finishes tasks, or needs input. Format code, send notifications, validate commands, and enforce project rules.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0061,Hooks reference,https://code.claude.com/docs/en/hooks.md,external,code.claude.com,ok,200,https://code.claude.com/docs/en/hooks.md,https://code.claude.com/docs/en/hooks.md,text/markdown; charset=utf-8,,,,,,,Anthropic,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0062,Common workflows - Claude Code,https://code.claude.com/docs/en/common-workflows,external,code.claude.com,ok,200,https://code.claude.com/docs/en/common-workflows,https://code.claude.com/docs/en/common-workflows,text/html; charset=utf-8,Common workflows - Claude Code Docs,"Step-by-step guides for exploring codebases, fixing bugs, refactoring, testing, and other everyday tasks with Claude Code.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0063,Manage multiple agents with agent view,https://code.claude.com/docs/en/agent-view.md,external,code.claude.com,ok,200,https://code.claude.com/docs/en/agent-view.md,https://code.claude.com/docs/en/agent-view.md,text/markdown; charset=utf-8,,,,,,,Anthropic,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0064,Run agents in parallel,https://code.claude.com/docs/en/agents.md,external,code.claude.com,ok,200,https://code.claude.com/docs/en/agents.md,https://code.claude.com/docs/en/agents.md,text/markdown; charset=utf-8,,,,,,,Anthropic,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0065,Orchestrate subagents at scale with dynamic workflows,https://code.claude.com/docs/en/workflows,external,code.claude.com,ok,200,https://code.claude.com/docs/en/workflows,https://code.claude.com/docs/en/workflows,text/html; charset=utf-8,Orchestrate subagents at scale with dynamic workflows - Claude Code Docs,"Dynamic workflows orchestrate many subagents from a script Claude writes and you can rerun. Use them for codebase audits, large migrations, and cross-checked research.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0066,Create plugins,https://code.claude.com/docs/en/plugins,external,code.claude.com,ok,200,https://code.claude.com/docs/en/plugins,https://code.claude.com/docs/en/plugins,text/html; charset=utf-8,Create plugins - Claude Code Docs,"Create custom plugins to extend Claude Code with skills, agents, hooks, and MCP servers.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0067,Model Context Protocol,https://modelcontextprotocol.io/docs/getting-started/intro,external,modelcontextprotocol.io,ok,200,https://modelcontextprotocol.io/docs/getting-started/intro,https://modelcontextprotocol.io/docs/getting-started/intro,text/html; charset=utf-8,What is the Model Context Protocol (MCP)? - Model Context Protocol,,,,,,Model Context Protocol,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0068,Allowing GitHub Copilot CLI to work autonomously,https://docs.github.com/en/copilot/concepts/agents/copilot-cli/autopilot,external,docs.github.com,ok,200,https://docs.github.com/en/copilot/concepts/agents/copilot-cli/autopilot,https://docs.github.com/en/copilot/concepts/agents/copilot-cli/autopilot,text/html; charset=utf-8,Allowing GitHub Copilot CLI to work autonomously - GitHub Docs,"The CLI's autopilot mode lets Copilot CLI work autonomously on a task, carrying out multiple steps until the task is complete.",,,,,GitHub Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0069,opencode-scheduler,https://github.com/different-ai/opencode-scheduler,external,github.com,ok,200,https://github.com/different-ai/opencode-scheduler,https://github.com/different-ai/opencode-scheduler,text/html; charset=utf-8,GitHub - different-ai/opencode-scheduler: OpenCode plugin for scheduling recurring jobs using launchd (Mac) or systemd (Linux) · GitHub,OpenCode plugin for scheduling recurring jobs using launchd (Mac) or systemd (Linux) - different-ai/opencode-scheduler,,2026-01-04,2026,different-ai/opencode-scheduler,GitHub,,,,github-api,different-ai/opencode-scheduler,442,30,14,OpenCode plugin for scheduling recurring jobs using launchd (Mac) or systemd (Linux),MIT,2026-01-04T03:04:58Z,2026-07-18T06:09:01Z,,,2026-07-18T08:16:45+00:00
ale-0070,Agent-Loop-Skills,https://github.com/gaasher/Agent-Loop-Skills,external,github.com,ok,200,https://github.com/gaasher/Agent-Loop-Skills,https://github.com/gaasher/Agent-Loop-Skills,text/html; charset=utf-8,"GitHub - gaasher/Agent-Loop-Skills: Loop until it's better — drop-in agentic loops (autoresearch, scientific writing, data analysis, code/SQL/prompt optimization, red-teaming) as open-standard Agent Skills. Verification-gated; native on Claude Code, portable across Codex, Cursor & other Skills hosts. · GitHub","Loop until it's better — drop-in agentic loops (autoresearch, scientific writing, data analysis, code/SQL/prompt optimization, red-teaming) as open-standard Agent Skills. Verification-gated; native on Claude Code, portable across Codex, Cursor & other Skills hosts. - gaasher/Agent-Loop-Skills",,2026-06-15,2026,gaasher/Agent-Loop-Skills,GitHub,,,,github-api,gaasher/Agent-Loop-Skills,134,15,1,"Loop until it's better — drop-in agentic loops (autoresearch, scientific writing, data analysis, code/SQL/prompt optimization, red-teaming) as open-standard Agent Skills. Verification-gated; native on Claude Code, portable across Codex, Cursor & other Skills hosts.",MIT,2026-06-15T02:01:33Z,2026-07-17T22:55:10Z,,,2026-07-18T08:16:45+00:00
ale-0071,launch-your-agent,https://github.com/anthropics/launch-your-agent,external,github.com,ok,200,https://github.com/anthropics/launch-your-agent,https://github.com/anthropics/launch-your-agent,text/html; charset=utf-8,"GitHub - anthropics/launch-your-agent: Claude Code skills that take a founder from idea to a live Claude Managed Agent: interview, scope a v0, launch in their own account, grade it, iterate, and schedule it · GitHub","Claude Code skills that take a founder from idea to a live Claude Managed Agent: interview, scope a v0, launch in their own account, grade it, iterate, and schedule it - anthropics/launch-your-agent",,2026-06-16,2026,anthropics/launch-your-agent,GitHub,,,,github-api,anthropics/launch-your-agent,814,154,2,"Claude Code skills that take a founder from idea to a live Claude Managed Agent: interview, scope a v0, launch in their own account, grade it, iterate, and schedule it",Apache-2.0,2026-06-16T14:49:50Z,2026-07-18T05:18:12Z,,,2026-07-18T08:16:45+00:00
ale-0072,Run long horizon tasks with Codex,https://developers.openai.com/blog/run-long-horizon-tasks-with-codex,external,developers.openai.com,ok,200,https://developers.openai.com/blog/run-long-horizon-tasks-with-codex,https://developers.openai.com/blog/run-long-horizon-tasks-with-codex,text/html; charset=utf-8,Run long horizon tasks with Codex | OpenAI Developers,OpenAI Developer Blog,,,,,OpenAI Developers,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0073,Best practices - ChatGPT Learn,https://learn.chatgpt.com/guides/best-practices,external,learn.chatgpt.com,ok,200,https://learn.chatgpt.com/guides/best-practices,https://learn.chatgpt.com/guides/best-practices,text/html; charset=utf-8,Best practices | ChatGPT Learn,Getting started with Codex and proven practices for better results,,,,,ChatGPT Learn,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0074,Agents SDK,https://developers.openai.com/api/docs/guides/agents,external,developers.openai.com,ok,200,https://developers.openai.com/api/docs/guides/agents,https://developers.openai.com/api/docs/guides/agents,text/html; charset=utf-8,Agents SDK | OpenAI API,Learn how the OpenAI Agents SDK fits together and which docs to read next.,,,,,OpenAI Developers,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0075,Agents - OpenAI Agents SDK,https://openai.github.io/openai-agents-python/agents/,external,openai.github.io,ok,200,https://openai.github.io/openai-agents-python/agents/,https://openai.github.io/openai-agents-python/agents/,text/html; charset=utf-8,Agents - OpenAI Agents SDK,,,,,,openai.github.io,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0076,Running agents,https://developers.openai.com/api/docs/guides/agents/running-agents,external,developers.openai.com,ok,200,https://developers.openai.com/api/docs/guides/agents/running-agents,https://developers.openai.com/api/docs/guides/agents/running-agents,text/html; charset=utf-8,Running agents | OpenAI API,"Learn how to run agents, stream output, and choose the right conversation-state strategy in the OpenAI Agents SDK.",,,,,OpenAI Developers,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0077,Integrations and observability,https://developers.openai.com/api/docs/guides/agents/integrations-observability,external,developers.openai.com,ok,200,https://developers.openai.com/api/docs/guides/agents/integrations-observability,https://developers.openai.com/api/docs/guides/agents/integrations-observability,text/html; charset=utf-8,Integrations and observability | OpenAI API,Learn how to integrate MCP into Agents SDK workflows and how to trace and debug runs.,,,,,OpenAI Developers,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0078,Sandbox Agents,https://developers.openai.com/api/docs/guides/agents/sandboxes,external,developers.openai.com,ok,200,https://developers.openai.com/api/docs/guides/agents/sandboxes,https://developers.openai.com/api/docs/guides/agents/sandboxes,text/html; charset=utf-8,Sandbox Agents | OpenAI API,"Learn how sandboxes fit into Agents SDK workflows, when to use them, and how orchestration stays separate from execution.",,,,,OpenAI Developers,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0079,Guardrails and human review,https://developers.openai.com/api/docs/guides/agents/guardrails-approvals,external,developers.openai.com,ok,200,https://developers.openai.com/api/docs/guides/agents/guardrails-approvals,https://developers.openai.com/api/docs/guides/agents/guardrails-approvals,text/html; charset=utf-8,Guardrails and human review | OpenAI API,"Learn how to use guardrails and human review in the OpenAI Agents SDK for safer, more controlled workflows.",,,,,OpenAI Developers,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0080,ChatGPT Work and the Codex Desktop App,https://openai.com/index/chatgpt-for-your-most-ambitious-work/,external,openai.com,ok,200,https://openai.com/index/chatgpt-for-your-most-ambitious-work/,https://openai.com/index/chatgpt-for-your-most-ambitious-work/,text/html; charset=utf-8,ChatGPT is now a partner for your most ambitious work | OpenAI,"ChatGPT Work is an agent that can take action across your apps and files, stay with a project for hours if needed, and turn a goal into finished work.",,,,,OpenAI,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0081,Building agents with the Claude Agent SDK,https://code.claude.com/docs/en/agent-sdk/overview.md,external,code.claude.com,ok,200,https://code.claude.com/docs/en/agent-sdk/overview.md,https://code.claude.com/docs/en/agent-sdk/overview.md,text/markdown; charset=utf-8,,,,,,,Anthropic,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0082,How the agent loop works,https://code.claude.com/docs/en/agent-sdk/agent-loop,external,code.claude.com,ok,200,https://code.claude.com/docs/en/agent-sdk/agent-loop,https://code.claude.com/docs/en/agent-sdk/agent-loop,text/html; charset=utf-8,How the agent loop works - Claude Code Docs,"Understand the message lifecycle, tool execution, context window, and architecture that power your SDK agents.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0083,Extend Claude with skills,https://code.claude.com/docs/en/skills,external,code.claude.com,ok,200,https://code.claude.com/docs/en/skills,https://code.claude.com/docs/en/skills,text/html; charset=utf-8,Extend Claude with skills - Claude Code Docs,"Create, manage, and share skills to extend Claude's capabilities in Claude Code. Includes custom commands and bundled skills.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0084,Create custom subagents,https://code.claude.com/docs/en/sub-agents,external,code.claude.com,ok,200,https://code.claude.com/docs/en/sub-agents,https://code.claude.com/docs/en/sub-agents,text/html; charset=utf-8,Create custom subagents - Claude Code Docs,Create and use specialized AI subagents in Claude Code for task-specific workflows and improved context management.,,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0085,Writing effective tools for AI agents,https://www.anthropic.com/engineering/writing-tools-for-agents,external,www.anthropic.com,ok,200,https://www.anthropic.com/engineering/writing-tools-for-agents,https://www.anthropic.com/engineering/writing-tools-for-agents,text/html; charset=utf-8,Writing effective tools for AI agents—using AI agents \ Anthropic,Writing effective tools for AI agents—using AI agents,,,,,Anthropic,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0086,Introducing advanced tool use on the Claude Developer Platform,https://www.anthropic.com/engineering/advanced-tool-use?e45d281a_page=3,external,www.anthropic.com,ok,200,https://www.anthropic.com/engineering/advanced-tool-use?e45d281a_page=3,https://www.anthropic.com/engineering/advanced-tool-use?e45d281a_page=3,text/html; charset=utf-8,Introducing advanced tool use on the Claude Developer Platform \ Anthropic,"Claude can now discover, learn, and execute tools dynamically to enable agents that take action in the real world. Here’s how.",,,,,Anthropic,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0087,Effective harnesses for long-running agents,https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents,external,www.anthropic.com,ok,200,https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents,https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents,text/html; charset=utf-8,Effective harnesses for long-running agents \ Anthropic,"Anthropic is an AI safety and research company that's working to build reliable, interpretable, and steerable AI systems.",,,,,Anthropic,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0088,Claude Code best practices,https://code.claude.com/docs/en/best-practices,external,code.claude.com,ok,200,https://code.claude.com/docs/en/best-practices,https://code.claude.com/docs/en/best-practices,text/html; charset=utf-8,Best practices for Claude Code - Claude Code Docs,"Tips and patterns for getting the most out of Claude Code, from configuring your environment to scaling across parallel sessions.",,,,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0089,Claude Managed Agents: Scheduled Deployments and Vaults,https://claude.com/blog/whats-new-in-claude-managed-agents,external,claude.com,ok,200,https://claude.com/blog/whats-new-in-claude-managed-agents,https://claude.com/blog/whats-new-in-claude-managed-agents,text/html; charset=utf-8,New in Claude Managed Agents: run agents on a schedule and store environment variables in vaults | Claude by Anthropic,Claude Managed Agents now supports scheduled deployments and vaults: run agents on a cron schedule and securely authenticate CLI tools and other services.,,,,,Claude,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0090,Getting Started with Loops,https://claude.com/blog/getting-started-with-loops,external,claude.com,ok,200,https://claude.com/blog/getting-started-with-loops,https://claude.com/blog/getting-started-with-loops,text/html; charset=utf-8,Loop engineering: Getting started with loops | Claude by Anthropic,"Loop engineering with Anthropic's Claude Code: design turn-based, goal, time, and proactive agent loops that run to a stop condition.",,,,,Claude,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0091,"Claude Code What's New, Week 28",https://code.claude.com/docs/en/whats-new/2026-w28,external,code.claude.com,ok,200,https://code.claude.com/docs/en/whats-new/2026-w28,https://code.claude.com/docs/en/whats-new/2026-w28,text/html; charset=utf-8,"Week 28 · July 6–10, 2026 - Claude Code Docs","Browse external sites from the Desktop app's built-in browser, run a full setup checkup with /doctor, and pick up auto mode transcript protections and agent view upgrades.",,,2026,,Claude Code Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0092,GitHub Agentic Workflows,https://github.github.com/gh-aw/,external,github.github.com,ok,200,https://github.github.com/gh-aw/,https://github.github.com/gh-aw/,text/html; charset=utf-8,Home | GitHub Agentic Workflows,Write repository automation workflows in natural language using markdown files and run them as GitHub Actions. Use AI agents with strong guardrails to automate your development workflow.,,,,,GitHub Agentic Workflows,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0093,Continuous AI,https://githubnext.com/projects/continuous-ai/,external,githubnext.com,ok,200,https://githubnext.com/projects/continuous-ai/,https://githubnext.com/projects/continuous-ai/,text/html; charset=utf-8,Continuous AI,Exploring LLM-powered automation in platform-based software collaboration,,,,,githubnext.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0094,Automate repository tasks with GitHub Agentic Workflows,https://github.blog/ai-and-ml/automate-repository-tasks-with-github-agentic-workflows/,external,github.blog,ok,200,https://github.blog/ai-and-ml/automate-repository-tasks-with-github-agentic-workflows/,https://github.blog/ai-and-ml/automate-repository-tasks-with-github-agentic-workflows/,text/html; charset=UTF-8,Automate repository tasks with GitHub Agentic Workflows - The GitHub Blog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon,"Build automations using coding agents in GitHub Actions to handle triage, documentation, code quality, and more.","Don Syme, Peli de Halleux",2026-02-13,2026,,The GitHub Blog,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0095,Continuous AI in practice: What developers can automate today with agentic CI,https://github.blog/ai-and-ml/generative-ai/continuous-ai-in-practice-what-developers-can-automate-today-with-agentic-ci/,external,github.blog,ok,200,https://github.blog/ai-and-ml/generative-ai/continuous-ai-in-practice-what-developers-can-automate-today-with-agentic-ci/,https://github.blog/ai-and-ml/generative-ai/continuous-ai-in-practice-what-developers-can-automate-today-with-agentic-ci/,text/html; charset=UTF-8,Continuous AI in practice: What developers can automate today with agentic CI - The GitHub Blog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon,Think of Continuous AI as background agents that operate in your repository for tasks that require reasoning.,GitHub Staff,2026-02-05,2026,,The GitHub Blog,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0096,About GitHub Copilot coding agent,https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-coding-agent,external,docs.github.com,ok,200,https://docs.github.com/en/copilot/concepts/agents/cloud-agent/about-cloud-agent,https://docs.github.com/en/copilot/concepts/agents/cloud-agent/about-cloud-agent,text/html; charset=utf-8,About GitHub Copilot cloud agent - GitHub Docs,"Copilot can research a repository, create an implementation plan, and make code changes on a branch. You can review the diff, iterate, and create a pull request when you're ready.",,,,,GitHub Docs,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0097,GitHub Copilot: Meet the new coding agent,https://github.blog/news-insights/product-news/github-copilot-meet-the-new-coding-agent/,external,github.blog,ok,200,https://github.blog/news-insights/product-news/github-copilot-meet-the-new-coding-agent/,https://github.blog/news-insights/product-news/github-copilot-meet-the-new-coding-agent/,text/html; charset=UTF-8,GitHub Copilot: Meet the new coding agent - The GitHub Blog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon,"GitHub Copilot has a new feature: a coding agent that can implement a task or issue, run in the background with GitHub Actions, and more.",Thomas Dohmke,2025-05-19,2025,,The GitHub Blog,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0098,GitHub Copilot for Jira Is Now Generally Available,https://github.blog/changelog/2026-06-25-github-copilot-for-jira-is-now-generally-available/,external,github.blog,ok,200,https://github.blog/changelog/2026-06-25-github-copilot-for-jira-is-now-generally-available/,https://github.blog/changelog/2026-06-25-github-copilot-for-jira-is-now-generally-available/,text/html; charset=UTF-8,GitHub Copilot for Jira is now generally available - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon,"GitHub Copilot for Jira is now generally available. Since launching the public preview in March 2026, we have shipped a series of enhancements based on your feedback, including model selection,…",,,2026,,The GitHub Blog,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0099,Copilot Agent Session Streaming (Public Preview),https://github.blog/changelog/2026-07-02-copilot-agent-session-streaming-is-now-in-public-preview/,external,github.blog,ok,200,https://github.blog/changelog/2026-07-02-copilot-agent-session-streaming-is-now-in-public-preview/,https://github.blog/changelog/2026-07-02-copilot-agent-session-streaming-is-now-in-public-preview/,text/html; charset=UTF-8,Copilot agent session streaming is now in public preview - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon,"GitHub Enterprise Cloud customers with enterprise managed users can now access GitHub Copilot agent session data across all Copilot clients, including: Cloud agents operating on github.com and data resident deployments…",,,2026,,The GitHub Blog,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0100,Security Reviews in the GitHub Copilot App,https://github.blog/changelog/2026-07-14-security-reviews-now-available-in-the-github-copilot-app,external,github.blog,ok,200,https://github.blog/changelog/2026-07-14-security-reviews-now-available-in-the-github-copilot-app/,https://github.blog/changelog/2026-07-14-security-reviews-now-available-in-the-github-copilot-app/,text/html; charset=UTF-8,Security reviews now available in the GitHub Copilot app - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon,"You can now run a security review on your in-flight code changes directly from the GitHub Copilot app. The /security-review slash command is shipping in public preview, bringing the same…",,,2026,,The GitHub Blog,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0101,Cursor cloud agents,https://cursor.com/docs/cloud-agent,external,cursor.com,ok,200,https://cursor.com/docs/cloud-agent,https://cursor.com/docs/cloud-agent,text/html; charset=utf-8,Cloud Agents | Cursor Docs,Run Agent in the cloud for continuous coding assistance.,,,,,Cursor Documentation,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0102,Cursor 3.8: Improvements to Cursor Automations,https://cursor.com/changelog/06-18-26,external,cursor.com,ok,200,https://cursor.com/changelog/06-18-26,https://cursor.com/changelog/06-18-26,text/html; charset=utf-8,Improvements to Cursor Automations · Cursor,,,,,,Cursor,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0103,Expanding Our Long-Running Agents Research Preview,https://cursor.com/blog/long-running-agents,external,cursor.com,ok,200,https://cursor.com/blog/long-running-agents,https://cursor.com/blog/long-running-agents,text/html; charset=utf-8,Expanding our long-running agents research preview · Cursor,"Long-running agents are now available in the Cursor web app for Ultra, Teams, and Enterprise users.",Cursor Team,,,,Cursor,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0104,"Cursor 3.11: Side Chats, Transcript Search, and Cloud Agent Hooks",https://cursor.com/changelog/side-chat,external,cursor.com,ok,200,https://cursor.com/changelog/side-chat,https://cursor.com/changelog/side-chat,text/html; charset=utf-8,Side Chats and Conversation Search · Cursor,,,,,,Cursor,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0105,Jules,https://jules.google/docs,external,jules.google,ok,200,https://jules.google/docs,https://jules.google/docs,text/html,Getting started | Jules,Set up and run your first task with Jules,,,,,Jules,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0106,Devin Docs,https://docs.devin.ai/get-started/devin-intro,external,docs.devin.ai,ok,200,https://docs.devin.ai/get-started/devin-intro,https://docs.devin.ai/get-started/devin-intro,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0107,"Amp: Agents, Anywhere",https://ampcode.com/news/agents-anywhere,external,ampcode.com,ok,200,https://ampcode.com/news/agents-anywhere,https://ampcode.com/news/agents-anywhere,text/html,"Agents, Anywhere - Amp",Remotely start agents anywhere you can run 'amp',,,,,ampcode.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0108,ReAct: Synergizing Reasoning and Acting in Language Models,https://arxiv.org/abs/2210.03629,external,arxiv.org,ok,200,https://arxiv.org/abs/2210.03629,https://openreview.net/forum?id=WE_vluYUL-X,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0109,Reflexion: Language Agents with Verbal Reinforcement Learning,https://arxiv.org/abs/2303.11366,external,arxiv.org,ok,200,https://arxiv.org/abs/2303.11366,https://proceedings.neurips.cc/paper_files/paper/2023/hash/1b44b878bb782e6954cd888628510e90-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0110,Self-Refine: Iterative Refinement with Self-Feedback,https://arxiv.org/abs/2303.17651,external,arxiv.org,ok,200,https://arxiv.org/abs/2303.17651,https://proceedings.neurips.cc/paper_files/paper/2023/hash/91edff07232fb1b55a505a9e9f6c0ff3-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0111,CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing,https://arxiv.org/abs/2305.11738,external,arxiv.org,ok,200,https://arxiv.org/abs/2305.11738,https://proceedings.iclr.cc/paper_files/paper/2024/hash/fef126561bbf9d4467dbb8d27334b8fe-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0112,Tree of Thoughts,https://arxiv.org/abs/2305.10601,external,arxiv.org,ok,200,https://arxiv.org/abs/2305.10601,https://proceedings.neurips.cc/paper_files/paper/2023/hash/271db9922b8d1f4dd7aaef84ed5ac703-Abstract.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0113,Graph of Thoughts,https://arxiv.org/abs/2308.09687,external,arxiv.org,ok,200,https://arxiv.org/abs/2308.09687,https://ojs.aaai.org/index.php/AAAI/article/view/29720,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0114,Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models,https://arxiv.org/abs/2310.04406,external,arxiv.org,ok,200,https://arxiv.org/abs/2310.04406,https://proceedings.mlr.press/v235/zhou24r.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0115,Voyager: An Open-Ended Embodied Agent with Large Language Models,https://arxiv.org/abs/2305.16291,external,arxiv.org,ok,200,https://arxiv.org/abs/2305.16291,https://openreview.net/forum?id=ehfRiF0R3a,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0116,Generative Agents: Interactive Simulacra of Human Behavior,https://arxiv.org/abs/2304.03442,external,arxiv.org,ok,200,https://arxiv.org/abs/2304.03442,https://doi.org/10.1145/3586183.3606763,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0117,Measuring AI Ability to Complete Long Software Tasks,https://arxiv.org/abs/2503.14499,external,arxiv.org,ok,200,https://arxiv.org/abs/2503.14499,https://proceedings.neurips.cc/paper_files/paper/2025/hash/85069585133c4c168c865e65d72e9775-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0118,Measuring AI Ability to Complete Long Tasks,https://metr.org/blog/2025-03-19-measuring-ai-ability-to-complete-long-tasks/,external,metr.org,ok,200,https://metr.org/blog/2025-03-19-measuring-ai-ability-to-complete-long-tasks/,https://metr.org/blog/2025-03-19-measuring-ai-ability-to-complete-long-tasks/,text/html; charset=UTF-8,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-18T08:16:45+00:00
ale-0119,Reflection-Driven Control for Trustworthy Code Agents,https://arxiv.org/abs/2512.21354,external,arxiv.org,ok,200,https://arxiv.org/abs/2512.21354,https://openreview.net/forum?id=vUtz66IHD1,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0120,Hyperagents,https://arxiv.org/abs/2603.19461,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.19461,https://arxiv.org/abs/2603.19461,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0121,PARC: An Autonomous Self-Reflective Coding Agent for Robust Execution of Long-Horizon Tasks,https://arxiv.org/abs/2512.03549,external,arxiv.org,ok,200,https://arxiv.org/abs/2512.03549,https://arxiv.org/abs/2512.03549,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0122,When the Specification Emerges: Benchmarking Faithfulness Loss in Long-Horizon Coding Agents,https://arxiv.org/abs/2603.17104,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.17104,https://arxiv.org/abs/2603.17104,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0123,Reflexion code,https://github.com/noahshinn/reflexion,external,github.com,ok,200,https://github.com/noahshinn/reflexion,https://github.com/noahshinn/reflexion,text/html; charset=utf-8,GitHub - noahshinn/reflexion: [NeurIPS 2023] Reflexion: Language Agents with Verbal Reinforcement Learning · GitHub,[NeurIPS 2023] Reflexion: Language Agents with Verbal Reinforcement Learning - noahshinn/reflexion,,2023-03-22,2023,noahshinn/reflexion,GitHub,,,,github-api,noahshinn/reflexion,3205,312,23,[NeurIPS 2023] Reflexion: Language Agents with Verbal Reinforcement Learning,MIT,2023-03-22T06:38:53Z,2026-07-16T12:01:06Z,,,2026-07-18T08:16:45+00:00
ale-0124,Stop Hand-Holding Your Coding Agent: Engineering the Loops that Replace Step-by-Step Prompting,https://arxiv.org/abs/2607.00038,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.00038,https://arxiv.org/abs/2607.00038,text/html; charset=utf-8,[2607.00038] Stop Hand-Holding Your Coding Agent: Engineering the Loops that Replace Step-by-Step Prompting,"In mid-2026 a slogan reorganized how practitioners talk about coding agents: stop prompting your agent, start designing the loop that prompts it. We take this claim seriously and give it a careful treatment. We call the object of the new practice the loop specification: a bounded, reusable artifact, made of a trigger, a goal, a verification step, a stopping rule and a memory, that a human hands to an agent harness (such as Claude Code or Codex) so the agent pursues a goal on its own, in place of step-by-step prompting. We distinguish this external loop specification from two things it is often confused with: an ordinary programming loop, and the internal perceive-act-observe cycle that the harness already provides as plumbing. We position loop engineering as a new layer in the progression from prompt to context to harness to loop, and we argue, against the stronger headlines, that it does not retire prompt engineering; loop and prompt are distinct tools with distinct uses. We offer four contributions: a definition and scope for the discipline; an anatomy and taxonomy of loop specifications organized around trigger, goal type, a five-level verification ladder, architecture, and named terminal states; a descriptive analysis of the Loop Library, a public corpus of fifty real loops that we code by hand; and a set of design principles and anti-patterns grounded in the scientific literature on self-correction, reward hacking and model-as-judge fragility. The corpus shows that practice has matured most where the discipline says it matters: seventy percent of loops verify in the autonomous zone of the ladder and seventy-four percent name their terminal states, while automated triggering and durable memory remain comparatively underdeveloped. We close with the limits the practice must respect, including the verification burden, comprehension debt and the risk of cognitive surrender.",Sandeco Macedo,2026-06-28,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,,,2607.00038,,2026-07-18T08:16:45+00:00
ale-0125,From Question Answering to Task Completion: A Survey on Agent System and Harness Design,https://arxiv.org/abs/2606.20683,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.20683,https://arxiv.org/abs/2606.20683,text/html; charset=utf-8,[2606.20683] From Question Answering to Task Completion: A Survey on Agent System and Harness Design,"LLM-based agents mark a shift from passive question answering to active task completion: they perceive environments, invoke tools, maintain state, and act over extended horizons. As agent systems have evolved from prompt engineering to workflows and context engineering, harness engineering, and agent-native training with co-evolution, a central question has become increasingly important: where does the bottleneck in agent performance reside, in the foundation model, in the execution harness, or in the coupling between them? This survey examines LLM-based agents through a model-harness lens. We first clarify the functional definition of agents and the implementation view of an LLM-based agent as a foundation model coupled with an execution harness. We then analyze the limits of model-centric scaling, trace four paradigms of agent engineering, and decompose the execution harness into six coupled runtime responsibilities: observation, context, control, action, state, and verification. Using this decomposition, we map task properties and domain pressures to harness configurations, review benchmark and evaluation practices, and synthesize model-harness evidence on how runtime design affects long-horizon task completion, efficiency, and reliability. Finally, we identify open challenges in value-aware evaluation, safety, harness generalization, and model-harness co-evolution. Rather than treating agents as models with auxiliary tools, this survey argues that agent quality -- including success, efficiency, safety, and generalization -- emerges from the interaction between model capability, runtime infrastructure, task structure, and evaluation design. A collection of papers discussed in this survey is provided in https://github.com/ggjy/Awesome-Agent-Engineering.",Jianyuan Guo; Zhiwei Hao; Chengcheng Wang; Cheng Fan; Tingzhang Luo; Hongguang Li; Ying Gao; Hefei Mei; Jiankun Peng; Rongjian Xu; Minjing Dong; Han Wu; Mengyu Zheng; Kai Han; Shiqi Wang; Chang Xu; Yunhe Wang,2026-06-14,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2606.20683,,2026-07-18T08:16:45+00:00
ale-0126,MOSS: Self-Evolution through Source-Level Rewriting in Autonomous Agent Systems,https://arxiv.org/abs/2605.22794,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.22794,https://arxiv.org/abs/2605.22794,text/html; charset=utf-8,[2605.22794] MOSS: Self-Evolution through Source-Level Rewriting in Autonomous Agent Systems,"Autonomous agentic systems are largely static after deployment: they do not learn from user interactions, and recurring failures persist until the next human-driven update ships a fix. Self-evolving agents have emerged in response, but all confine evolution to text-mutable artifacts -- skill files, prompt configurations, memory schemas, workflow graphs -- and leave the agent harness untouched. Since routing, hook ordering, state invariants, and dispatch live in code rather than in any text artifact, an entire class of structural failure is physically unreachable from the text layer. We argue that source-level adaptation is a fundamentally more general medium: it is Turing-complete, a strict superset of every text-mutable scope, takes effect deterministically rather than through base-model compliance, and does not erode under long-context drift. We present MOSS, a system that performs self-rewriting at the source level on production agentic substrates. Each evolution is anchored to an automatically curated batch of production-failure evidence and proceeds through a deterministic multi-stage pipeline; code modification is delegated to a pluggable external coding-agent CLI while MOSS retains stage ordering and verdicts. Candidates are verified by replaying the batch against the candidate image in ephemeral trial workers, then promoted via user-consent-gated, in-place container swap with health-probe-gated rollback. On OpenClaw, MOSS lifts a four-task mean grader score from 0.25 to 0.61 in a single cycle without human intervention.",Qianshu Cai; Yonggang Zhang; Xianzhang Jia; Huajiang Zheng; Wei Xue; Jun Song; Xinmei Tian; Yike Guo,2026-05-21,2026,arXiv,arXiv,,"12 pages, 3 figures, 2 tables. Preprint. Code: https://github.com/hkgai-official/Moss",cs.AI,arxiv-api,,,,,,,,,2605.22794,,2026-07-18T08:16:45+00:00
ale-0127,METR Time Horizon 1.1,https://metr.org/blog/2026-1-29-time-horizon-1-1/,external,metr.org,ok,200,https://metr.org/blog/2026-1-29-time-horizon-1-1/,https://metr.org/blog/2026-1-29-time-horizon-1-1/,text/html; charset=UTF-8,Time Horizon 1.1 - METR Substack twitter Bluesky,"We’re releasing a new version of our time horizon estimates (TH1.1), using more tasks and a new eval infrastructure.",,2026-01-29,2026,METR Blog,metr.org,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0128,MetaSkill-Evolve: Recursive Self-Improvement via Two-Timescale Meta-Skill Evolution,https://arxiv.org/abs/2607.05297,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.05297,https://arxiv.org/abs/2607.05297,text/html; charset=utf-8,[2607.05297] MetaSkill-Evolve: Recursive Self-Improvement of LLM Agents via Two-Timescale Meta-Skill Evolution,"Recent LLM agents tackle increasingly long-horizon, open-ended tasks, and external skills, reusable procedural knowledge supplied to the agent, further extend this capability. However, a fixed, hand-authored skill is rarely optimal, and cannot adapt to the diversity of tasks an agent encounters. Self-improving agents address this by rewriting their own skill files from execution traces, yielding meaningful gains on challenging benchmarks. Yet such self-evolution remains non-recursive: it improves only the task skill (what the agent does) while the improvement procedure (how it improves) is authored once and held fixed. We introduce MetaSkill-Evolve, a two-timescale framework that makes agentic skill improvement recursive: every branch carries both a task skill $s$ and a branch-local meta-skill $m=(\psi,\sigma,\alpha,\pi,\varepsilon)$ whose five components parameterise the Analyzer, Retriever, Allocator, Proposer, and Evolver agents of the improvement pipeline. Task skills evolve on a fast loop while the meta-skill evolves on a slower one under the same pipeline applied to itself, with no additional model or objective. With all five pipeline agents sharing a single frozen backbone, MetaSkill-Evolve outperforms no-skill, static-skill, and single-level evolution baselines on three agentic benchmarks (OfficeQA, SealQA, ALFWorld), improving held-out test accuracy over the raw backbone by +23.54, +16.09, and +1.92 points respectively.",Zefeng Wang; Minxi Yan; Jinhe Bi; Sikuan Yan; Volker Tresp; Yunpu Ma,2026-07-06,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.05297,,2026-07-18T08:16:45+00:00
ale-0129,SkillOpt-Lite: Better and Faster Agent Self-Evolution via One Line of Vibe,https://arxiv.org/abs/2607.03451,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.03451,https://arxiv.org/abs/2607.03451,text/html; charset=utf-8,[2607.03451] SkillOpt-Lite: Better and Faster Agent Self-evolution via One Line of Vibe,"While skill optimization for autonomous agents has gained traction, existing methods rely on complex pipelines. This leaves a fundamental question unaddressed: What constitutes a minimal viable pipeline for skill optimization, where every component is justified by theory or empirical necessity? We formalize skill optimization via Zeroth-Order (ZO) optimization, mapping classical counterparts (central difference, trust regions) to recent literature. Noting that unlike blind numerical perturbations in classical ZO, skill trajectories serve as interpretable debugging feedback. Grounded in Claude Code philosophy and PAC learning, we establish three principles for convergence and generalization: file-system-based trajectory exploration, consensus attribute mining, and independent validation gating. Eliminating redundancies, we propose SkillOpt-Lite. It accelerates convergence and outperforms full SkillOpt: improving LiveMath by +8.8 points on GPT-5.5 and +25.4 points on GPT-5.4-nano, allowing the nano model to surpass standard GPT-5.4 optimized by SkillOpt. Finally, we integrate our framework into production coding agents like VSCode Copilot, enabling developers to evolve agent skills via one line of vibe. Because our framework treats all agent components simply as standard editable code, this minimal pipeline naturally generalizes to full harness optimization (HarnessOpt). On SpreadsheetBench, HarnessOpt enables GPT-5.4-nano to achieve 0.7758 accuracy, outperforming the larger GPT-5.5 running standard pipelines (0.7620). Code is available at https://github.com/EvolvingLMMs-Lab/SkillOpt-Lite.",Yifei Shen; Bo Li; Xinjie Zhang,2026-07-03,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,,,2607.03451,,2026-07-18T08:16:45+00:00
ale-0130,Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops,https://arxiv.org/abs/2607.07663,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07663,https://arxiv.org/abs/2607.07663,text/html; charset=utf-8,[2607.07663] Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops,"AI systems increasingly participate in their own improvement: revising their outputs, adapting their own harnesses during deployment, training on data they generate, and, increasingly, conducting AI research itself. This literature is described under a vocabulary (""self-refine,"" ""self-reward,"" ""self-play,"" ""self-evolve"") that conflates fundamentally different ambitions. We survey 1,250 arXiv papers (2024-2026) along two axes: what the system improves -- its behavior in deployment, its policy through training, its evaluator, or the research process itself -- and the degree of loop closure (human-in-the-loop to fully closed). The taxonomy separates bounded self-refinement -- convergent, evaluable, and already industrial practice -- from open-ended recursive self-improvement (RSI), which remains bounded by grounding requirements, collapse dynamics, and compute constraints on every measured axis. Its distinctive feature is a dedicated category for self-evaluation: every improvement loop is a claim that some signal can substitute for human judgment. We survey the evaluator design space -- judges, process reward models, verifiers, rubrics, meta-evaluation -- order the signals into a verification hierarchy from formal verifiers (strongest) to intrinsic self-assessment (weakest), and observe that demonstrated self-improvement strength tracks this hierarchy, that its failure modes (self-confirming loops, model collapse, diversity collapse) follow from its violations, and that the ""research direction-setting"" bottleneck keeping humans in the loop sits at the top of that hierarchy. We connect the technical literature to the theory of RSI limits and to the safety and governance questions raised by frontier-lab accounts of closing the loop, and identify governance-grade measurement of self-improvement as the field's most underpopulated niche.",Mingguang Chen; Licheng Wang; Bo Qu,2026-07-08,2026,arXiv,arXiv,,"42 pages, 6 figures",cs.AI,arxiv-api,,,,,,,,,2607.07663,,2026-07-18T08:16:45+00:00
ale-0131,From Atomic Actions to Standard Operating Procedures: Iterative Tool Optimization for Self-Evolving LLM Agents,https://arxiv.org/abs/2607.07321,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07321,https://arxiv.org/abs/2607.07321,text/html; charset=utf-8,[2607.07321] From Atomic Actions to Standard Operating Procedures: Iterative Tool Optimization for Self-Evolving LLM Agents,"Tool utilization enables Large Language Model (LLM) agents to interact with the real world and resolve complex tasks. However, existing agent frameworks predominantly rely on static toolsets composed of granular atomic actions (e.g., basic file I/O or single-turn search), which forces agents to reinvent low-level logic for every recurring workflow, leading to increased reasoning overhead and failure rates. In this study, we propose that agents can achieve self-evolution by synthesizing these atomic actions into reusable Standard Operating Procedures (SOPs), which function as callable higher-order tools that encapsulate multi-step logic. We further introduce EvoSOP, a framework that empowers agents to extract SOPs from execution trajectories and iteratively optimize the toolset through a systematic lifecycle of construction, merging, evaluation, and pruning. Extensive experiments demonstrate that EvoSOP significantly boosts task success rates while substantially reducing the number of interaction rounds compared to baselines. Our analysis also reveals that iterative tool optimization fosters reliable and efficient tool-use patterns, providing a scalable pathway for the development of self-evolving agents.",Haipeng Ding; Yuexiang Xie; Zhewei Wei; Yaliang Li; Bolin Ding,2026-07-08,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.07321,,2026-07-18T08:16:45+00:00
ale-0132,TTHE: Test-Time Harness Evolution,https://arxiv.org/abs/2607.08124,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08124,https://arxiv.org/abs/2607.08124,text/html; charset=utf-8,[2607.08124] TTHE: Test-Time Harness Evolution,"The behavior of an LLM agent is determined not only by the underlying model, but also by its harness: the executable program that constructs context, invokes tools, verifies intermediate results, and recovers from failures. Existing approaches optimize such harnesses before deployment, searching training or development data for a fixed agent workflow that is then frozen at test time. This limits adaptation when the test distribution, failure modes, or tool interactions differ from those seen during development. We ask whether the harness can instead be optimized during evaluation itself, using only the unlabeled execution traces the agent produces on the test inputs. We introduce Test-Time Harness Evolution (TTHE), which treats the executable harness as the state of test-time adaptation. During evaluation, TTHE maintains a population of candidate harnesses and refines them through an agentic proposer that reasons over their execution traces, without gold labels or task-specific supervision; a judge then commits an improved harness from execution-derived proxy signals, and the selected program persists to govern subsequent inputs. Crucially, TTHE does not update model weights, require gold labels, or train a separate adaptation model: solver, proposers, and judge are different roles and harnesses around the same frozen LLM, so all adaptation occurs through changes to the surrounding program. Across text-to-SQL, competitive programming, software engineering, data-science coding, and agentic tool-use tasks, TTHE improves fixed ReAct-style baseline harnesses, yielding persistent, inspectable improvements rather than a pre-searched workflow or per-query retries. These results recast test-time adaptation for LLM agents as evolution over executable control programs and identify execution-derived proxy reliability as a central challenge for robust unsupervised agent improvement.",Jun Nie; Yonggang Zhang; Jun Song; Qianshu Cai; Dahai Yu; Yike Guo; Xinmei Tian; Bo Han,2026-07-09,2026,arXiv,arXiv,,"15 pages, 5 figures",cs.SE,arxiv-api,,,,,,,,,2607.08124,,2026-07-18T08:16:45+00:00
ale-0133,DeepSearch-World: Self-Distillation for Deep Search Agents in a Verifiable Environment,https://arxiv.org/abs/2607.07820,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07820,https://arxiv.org/abs/2607.07820,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0134,What Makes a Good Bug Report for an AI Agent?,https://arxiv.org/abs/2607.07593,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07593,https://arxiv.org/abs/2607.07593,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0135,AutoPersonas: A Multi-Timescale Loop Engine for Open-Ended Persona Evolution,https://arxiv.org/abs/2607.08252,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08252,https://arxiv.org/abs/2607.08252,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0136,Agentic Data Environments,https://arxiv.org/abs/2607.07397,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07397,http://sites.computer.org/debull/A26mar/A26MAR-CD.pdf#page=7,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0137,"Better Harnesses, Smaller Models: Building 90% Cheaper Agents via Automated Harness Adaptation",https://arxiv.org/abs/2607.08938,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08938,https://arxiv.org/abs/2607.08938,text/html; charset=utf-8,"[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-18T08:16:45+00:00
ale-0138,Inside the Skill Market: From Software Engineering Activities to Reusable Agent Skills,https://arxiv.org/abs/2607.09065,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.09065,https://arxiv.org/abs/2607.09065,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0139,Harness Engineering for Self-Improvement,https://lilianweng.github.io/posts/2026-07-04-harness/,external,lilianweng.github.io,ok,200,https://lilianweng.github.io/posts/2026-07-04-harness/,https://lilianweng.github.io/posts/2026-07-04-harness/,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0140,"Compile, Then Page: Executable SOP Programs and a Capability-Gated Runtime",https://arxiv.org/abs/2607.11346,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.11346,https://arxiv.org/abs/2607.11346,text/html; charset=utf-8,"[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-18T08:16:45+00:00
ale-0141,Mako: A Self-Evolving Agentic Operating System for Autonomous Web Exploitation,https://arxiv.org/abs/2607.11288,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.11288,https://arxiv.org/abs/2607.11288,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0142,How Do Practitioners Build SE Agents? Insights from a Mixed-Methods Study,https://arxiv.org/abs/2607.10856,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.10856,https://arxiv.org/abs/2607.10856,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0143,Dynamic Agent Skills: A Lifecycle Survey and Taxonomy of Evolving Skill Libraries,https://arxiv.org/abs/2607.10113,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.10113,https://openreview.net/forum?id=cjU3YbcRr8,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0144,SIA: Self Improving AI with Harness & Weight Updates,https://arxiv.org/abs/2605.27276,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.27276,https://arxiv.org/abs/2605.27276,text/html; charset=utf-8,[2605.27276] SIA: Self Improving AI with Harness & Weight Updates,"Humans are the bottleneck in building and improving AI. Both the models and the agents that wrap them are written, tuned, and corrected by people. The long-horizon goal of an AI that can figure out how to improve itself remains open. Two largely disjoint research lines attack this bottleneck. The harness-update school has a meta-agent rewrite the scaffold of a task-specific agent (its tools, prompts, retry logic, and search procedure) while the model weights are held fixed. The test-time training school uses hand-written RL pipelines to update the model's own weights on task feedback while the harness is held fixed. These two silos operate in isolation. We propose SIA, a self-improving loop in which a language-model agent (the Feedback-Agent) updates both the harness and the weights of a task-specific agent. We evaluate across three contrasting domains: Chinese legal charge classification, low-level GPU kernel optimisation, and single-cell RNA denoising. Combining both levers outperforms scaffold iteration alone on all three benchmarks. SIA-W+H achieves 25.1% over prior SOTA on LawBench, 12.4% faster GPU kernels than prior SOTA (1,017 vs 1,161 {\mu}s), and 20.4% over prior SOTA on denoising. Harness updates make the model agentic, shaping how it searches and acts, while weight updates build the domain intuition that no prompt or scaffold can instil.",Prannay Hebbar; Yogendra Manawat; Samuel Verboomen; Alesia Ivanova; Selvam Palanimalai; Kunal Bhatia; Vignesh Baskaran,2026-05-26,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2605.27276,,2026-07-18T08:16:45+00:00
ale-0145,Universal Transformers,https://openreview.net/forum?id=HyzdRiR9Y7,external,openreview.net,ok,200,https://openreview.net/challenge?redirect=%2Fforum%3Fid%3DHyzdRiR9Y7,https://openreview.net/challenge?redirect=%2Fforum%3Fid%3DHyzdRiR9Y7,text/html; charset=utf-8,Verifying your browser | OpenReview,,Mostafa Dehghani; Stephan Gouws; Oriol Vinyals; Jakob Uszkoreit; Łukasz Kaiser,2019,2019,International Conference on Learning Representations (ICLR),OpenReview,,Published at ICLR 2019; venue and authors verified from the official OpenReview record.,,OpenReview,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0146,Looped Transformers as Programmable Computers,https://proceedings.mlr.press/v202/giannou23a.html,external,proceedings.mlr.press,ok,200,https://proceedings.mlr.press/v202/giannou23a.html,https://proceedings.mlr.press/v202/giannou23a.html,text/html; charset=utf-8,Looped Transformers as Programmable Computers,"Looped Transformers as Programmable ComputersAngeliki Giannou, Shashank Rajput, Jy-Yong Sohn, Kangwook Lee, Jason D. Lee, Dimitris P...",Angeliki Giannou; Shashank Rajput; Jy-Yong Sohn; Kangwook Lee; Jason D. Lee; Dimitris Papailiopoulos,2023-07-03,2023,International Conference on Machine Learning,PMLR,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0147,Looped Transformers are Better at Learning Learning Algorithms,https://openreview.net/forum?id=HHbRxoDTxE,external,openreview.net,ok,200,https://openreview.net/challenge?redirect=%2Fforum%3Fid%3DHHbRxoDTxE,https://openreview.net/challenge?redirect=%2Fforum%3Fid%3DHHbRxoDTxE,text/html; charset=utf-8,Verifying your browser | OpenReview,,Liu Yang; Kangwook Lee; Robert D. Nowak; Dimitris Papailiopoulos,2024,2024,International Conference on Learning Representations (ICLR),OpenReview,,Published at ICLR 2024; venue and authors verified from the official OpenReview record.,,OpenReview,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0148,On Expressive Power of Looped Transformers: Theoretical Analysis and Enhancement via Timestep Encoding,https://proceedings.mlr.press/v267/xu25x.html,external,proceedings.mlr.press,ok,200,https://proceedings.mlr.press/v267/xu25x.html,https://proceedings.mlr.press/v267/xu25x.html,text/html; charset=utf-8,On Expressive Power of Looped Transformers: Theoretical Analysis and Enhancement via Timestep Encoding,"On Expressive Power of Looped Transformers: Theoretical Analysis and Enhancement via Timestep EncodingKevin Xu, Issei SatoLooped Transformers provide ad...",Kevin Xu; Issei Sato,2025-10-06,2025,International Conference on Machine Learning,PMLR,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0149,Reasoning with Latent Thoughts: On the Power of Looped Transformers,https://iclr.cc/virtual/2025/poster/28971,external,iclr.cc,ok,200,https://iclr.cc/virtual/2025/poster/28971,https://iclr.cc/virtual/2025/poster/28971,text/html; charset=utf-8,ICLR Poster Reasoning with Latent Thoughts: On the Power of Looped Transformers ICLR 2025,,Nikunj Saunshi; Nishanth Dikkala; Zhiyuan Li; Sanjiv Kumar; Sashank J. Reddi,2025,2025,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published at ICLR 2025; metadata verified from the official conference poster page.,,ICLR proceedings,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0150,Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach,https://proceedings.neurips.cc/paper_files/paper/2025/hash/3b01972cf31e6fa0fe29e4b8b5c2a0a1-Abstract-Conference.html,external,proceedings.neurips.cc,ok,200,https://proceedings.neurips.cc/paper_files/paper/2025/hash/3b01972cf31e6fa0fe29e4b8b5c2a0a1-Abstract-Conference.html,https://proceedings.neurips.cc/paper_files/paper/2025/hash/3b01972cf31e6fa0fe29e4b8b5c2a0a1-Abstract-Conference.html,text/html; charset=utf-8,Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach,,Jonas Geiping; Sean McLeish; Neel Jain; John Kirchenbauer; Siddharth Singh; Brian Bartoldson; Bhavya Kailkhura; Abhinav Bhatele; Tom Goldstein,2025,2025,Advances in Neural Information Processing Systems 38 (NeurIPS 2025),Neural Information Processing Systems Foundation,,Published at NeurIPS 2025; the proceedings page's later web timestamp is not used as the conference year.,,NeurIPS proceedings,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0151,Mixture-of-Recursions: Learning Dynamic Recursive Depths for Adaptive Token-Level Computation,https://papers.nips.cc/paper_files/paper/2025/hash/8b08bbf8b420faa6eeb4020720582ec7-Abstract-Conference.html,external,papers.nips.cc,ok,200,https://papers.nips.cc/paper_files/paper/2025/hash/8b08bbf8b420faa6eeb4020720582ec7-Abstract-Conference.html,https://papers.nips.cc/paper_files/paper/2025/hash/8b08bbf8b420faa6eeb4020720582ec7-Abstract-Conference.html,text/html; charset=utf-8,Mixture-of-Recursions: Learning Dynamic Recursive Depths for Adaptive Token-Level Computation,,Sangmin Bae; Yujin Kim; Reza Bayat; Sungnyun Kim; Jiyoun Ha; Tal Schuster; Adam Fisch; Hrayr Harutyunyan; Ziwei Ji; Aaron Courville; Se-Young Yun,2025,2025,Advances in Neural Information Processing Systems 38 (NeurIPS 2025),Neural Information Processing Systems Foundation,,Published at NeurIPS 2025; the proceedings page's later web timestamp is not used as the conference year.,,NeurIPS proceedings,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0152,Scaling Latent Reasoning via Looped Language Models,https://arxiv.org/abs/2510.25741,external,arxiv.org,ok,200,https://arxiv.org/abs/2510.25741,https://arxiv.org/abs/2510.25741,text/html; charset=utf-8,[2510.25741] Scaling Latent Reasoning via Looped Language Models,"Modern LLMs are trained to ""think"" primarily via explicit text generation, such as chain-of-thought (CoT), which defers reasoning to post-training and under-leverages pre-training data. We present and open-source Ouro, named after the recursive Ouroboros, a family of pre-trained Looped Language Models (LoopLM) that instead build reasoning into the pre-training phase through (i) iterative computation in latent space, (ii) an entropy-regularized objective for learned depth allocation, and (iii) scaling to 7.7T tokens. Ouro 1.4B and 2.6B models enjoy superior performance that match the results of up to 12B SOTA LLMs across a wide range of benchmarks. Through controlled experiments, we show this advantage stems not from increased knowledge capacity, but from superior knowledge manipulation capabilities. We also show that LoopLM yields reasoning traces more aligned with final outputs than explicit CoT. We hope our results show the potential of LoopLM as a novel scaling direction in the reasoning era. Our model is available here: http://ouro-llm.github.io.",Rui-Jie Zhu; Zixuan Wang; Kai Hua; Tianyu Zhang; Ziniu Li; Haoran Que; Boyi Wei; Zixin Wen; Fan Yin; He Xing; Lu Li; Jiajun Shi; Kaijing Ma; Shanda Li; Taylor Kergan; Andrew Smith; Xingwei Qu; Mude Hui; Bohong Wu; Qiyang Min; Hongzhi Huang; Xun Zhou; Wei Ye; Jiaheng Liu; Jian Yang; Yunfeng Shi; Chenghua Lin; Enduo Zhao; Tianle Cai; Ge Zhang; Wenhao Huang; Yoshua Bengio; Jason Eshraghian,2025-10-29,2025,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,,,2510.25741,,2026-07-18T08:16:45+00:00
ale-0153,LoopFormer: Elastic-Depth Looped Transformers for Latent Reasoning via Shortcut Modulation,https://iclr.cc/virtual/2026/poster/10009450,external,iclr.cc,ok,200,https://iclr.cc/virtual/2026/poster/10009450,https://iclr.cc/virtual/2026/poster/10009450,text/html; charset=utf-8,ICLR Poster LoopFormer: Elastic-Depth Looped Transformers for Latent Reasoning via Shortcut Modulation ICLR 2026,,Ahmadreza Jeddi; Marco Ciccone; Babak Taati,2026,2026,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published at ICLR 2026; metadata verified from the official conference poster page.,,ICLR proceedings,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0154,MoDr: Mixture-of-Depth-Recurrent Transformers for Test-Time Reasoning,https://iclr.cc/virtual/2026/poster/10011117,external,iclr.cc,ok,200,https://iclr.cc/virtual/2026/poster/10011117,https://iclr.cc/virtual/2026/poster/10011117,text/html; charset=utf-8,ICLR Poster MoDr: Mixture-of-Depth-Recurrent Transformers for Test-Time Reasoning ICLR 2026,,Xiaojing Zhang; Haifeng Wu; Gang He; Jiyang Shen; Bochen Lyu; Zhanxing Zhu,2026,2026,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published at ICLR 2026; metadata verified from the official conference poster page.,,ICLR proceedings,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0155,ChainGPT: Dual-Reasoning Model with Recurrent Depth and Multi-Rank State Updates,https://iclr.cc/virtual/2026/poster/10007767,external,iclr.cc,ok,200,https://iclr.cc/virtual/2026/poster/10007767,https://iclr.cc/virtual/2026/poster/10007767,text/html; charset=utf-8,ICLR Poster ChainGPT: Dual-Reasoning Model with Recurrent Depth and Multi-Rank State Updates ICLR 2026,,Yunao Zheng; Xiaojie Wang; Lei Ren; Chen Wei,2026,2026,International Conference on Learning Representations (ICLR),International Conference on Learning Representations,,Published at ICLR 2026; metadata verified from the official conference poster page.,,ICLR proceedings,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0156,Think-at-Hard: Selective Latent Iterations to Improve Reasoning Language Models,https://openreview.net/forum?id=eQaJSRZiGn,external,openreview.net,ok,200,https://openreview.net/challenge?redirect=%2Fforum%3Fid%3DeQaJSRZiGn,https://openreview.net/challenge?redirect=%2Fforum%3Fid%3DeQaJSRZiGn,text/html; charset=utf-8,Verifying your browser | OpenReview,,Tianyu Fu; Yichen You; Zekai Chen; Guohao Dai; Huazhong Yang; Yu Wang,2026,2026,International Conference on Machine Learning (ICML),OpenReview,,Published at ICML 2026; venue and authors verified from the official OpenReview record.,,OpenReview,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0157,Parcae: Scaling Laws For Stable Looped Language Models,https://openreview.net/forum?id=ri0LAMdhd9,external,openreview.net,ok,200,https://openreview.net/challenge?redirect=%2Fforum%3Fid%3Dri0LAMdhd9,https://openreview.net/challenge?redirect=%2Fforum%3Fid%3Dri0LAMdhd9,text/html; charset=utf-8,Verifying your browser | OpenReview,,Hayden Prairie; Zachary Novack; Taylor Berg-Kirkpatrick; Daniel Y. Fu,2026,2026,Learning to Iterate Workshop at ICLR 2026,OpenReview,,Workshop paper at the Learning to Iterate Workshop at ICLR 2026; not an ICLR main-conference paper.,,OpenReview,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0158,SpiralFormer: Looped Transformers Can Learn Hierarchical Dependencies via Multi-Resolution Recursion,https://arxiv.org/abs/2602.11698,external,arxiv.org,ok,200,https://arxiv.org/abs/2602.11698,https://arxiv.org/abs/2602.11698,text/html; charset=utf-8,[2602.11698] SpiralFormer: Looped Transformers Can Learn Hierarchical Dependencies via Multi-Resolution Recursion,"Recursive (looped) Transformers decouple computational depth from parameter depth by repeatedly applying shared layers, providing an explicit architectural primitive for iterative refinement and latent reasoning. However, early looped Transformers often underperform non-recursive baselines of equal compute. While recent literature has introduced more effective recursion mechanisms to mitigate this gap, existing architectures still operate at a fixed, full-token resolution, neglecting the potential efficiency of computing over compressed latent representations. In this paper, we propose SpiralFormer, a looped Transformer that executes recurrence under a multi-resolution recursion schedule. We provide probing evidence that multi-resolution recursion enables the model to learn hierarchical dependencies by inducing iteration-wise functional specialization across different scales. Empirically, SpiralFormer achieves better parameter and compute efficiency than both looped and non-looped baselines across model scales from 160M to 1.4B, establishing sequence resolution as a potential axis for scaling recursive architectures.",Chengting Yu; Xiaobo Shu; Yadao Wang; Yizhen Zhang; Haoyi Wu; You Wu; Rujiao Long; Ziheng Chen; Yuchi Xu; Wenbo Su; Bo Zheng,2026-02-12,2026,arXiv,arXiv,,,cs.LG,arxiv-api,,,,,,,,,2602.11698,,2026-07-18T08:16:45+00:00
ale-0159,Training-Free Looped Transformers,https://arxiv.org/abs/2605.23872,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.23872,https://arxiv.org/abs/2605.23872,text/html; charset=utf-8,[2605.23872] Training-Free Looped Transformers,"We introduce training-free looped transformers, in which a lightweight inference-time wrapper loops a contiguous mid-stack block of layers of a frozen checkpoint without additional fine-tuning, continued training, or architectural changes. Unlike prior looped transformer methods that train with the looped structure end-to-end, we retrofit recurrence onto pretrained models at test time. We show that naive block reapplication usually degrades performance, highlighting the importance of the loop application strategy. Motivated by viewing a pre-norm transformer block as a forward Euler step on an ODE, we instead treat looping as a refinement of the same approximation, replacing one large update with smaller damped sub-steps. Across seven dense, sparse MoE, and MLA+MoE model families, our method improves Qwen3-4B-Instruct by +2.64 pp on MMLU-Pro, Qwen3-30B-A3B-Instruct by +1.14 pp on CommonsenseQA, and Moonlight-16B-A3B-Instruct by +1.20 pp on OpenBookQA.",Lizhang Chen; Jonathan Li; Chen Liang; Ni Lao; Qiang Liu,2026-05-22,2026,arXiv,arXiv,,,cs.LG,arxiv-api,,,,,,,,,2605.23872,,2026-07-18T08:16:45+00:00
ale-0160,"Loop, Think, & Generalize: Implicit Reasoning in Recurrent-Depth Transformers",https://arxiv.org/abs/2604.07822,external,arxiv.org,ok,200,https://arxiv.org/abs/2604.07822,https://arxiv.org/abs/2604.07822,text/html; charset=utf-8,"[2604.07822] Loop, Think, & Generalize: Implicit Reasoning in Recurrent-Depth Transformers","We study implicit reasoning, i.e. the ability to combine knowledge or rules within a single forward pass. While transformer-based large language models store substantial factual knowledge and rules, they often fail to compose this knowledge for implicit multi-hop reasoning, suggesting a lack of compositional generalization over their parametric knowledge. To address this limitation, we study recurrent-depth transformers, which enables iterative computation over the same transformer layers. We investigate two compositional generalization challenges under the implicit reasoning scenario: systematic generalization, i.e. combining knowledge that is never used for compositions during training, and depth extrapolation, i.e. generalizing from limited reasoning depth (e.g. training on up to 5-hop) to deeper compositions (e.g. 10-hop). Through controlled studies with models trained from scratch, we show that while vanilla transformers struggle with both generalization challenges, recurrent-depth transformers can effectively make such generalization. For systematic generalization, we find that this ability emerges through a three-stage grokking process, transitioning from memorization to in-distribution generalization and finally to systematic generalization, supported by mechanistic analysis. For depth extrapolation, we show that generalization beyond training depth can be unlocked by scaling inference-time recurrence, with more iterations enabling deeper reasoning. We further study how training strategies affect extrapolation, providing guidance on training recurrent-depth transformers, and identify a key limitation, overthinking, where excessive recurrence degrades predictions and limits generalization to very deep compositions.",Harsh Kohli; Srinivasan Parthasarathy; Huan Sun; Yuekun Yao,2026-04-09,2026,arXiv,arXiv,,"19 pages, 18 figures. Under review",cs.CL,arxiv-api,,,,,,,,,2604.07822,,2026-07-18T08:16:45+00:00
ale-0161,DeepLoop: Depth Scaling for Looped Transformers,https://arxiv.org/abs/2607.13491,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.13491,https://arxiv.org/abs/2607.13491,text/html; charset=utf-8,[2607.13491] DeepLoop: Depth Scaling for Looped Transformers,"Looped Transformers scale sequential computation by applying a compact stack of physical blocks for multiple rounds, increasing unrolled depth without increasing stored parameters. This reuse changes the residual-scaling problem: in an untied Transformer, each residual branch receives and applies its own parameter update, whereas in a looped Transformer one shared update aggregates gradients from repeated visits and is read back by those same visits in the next linearized forward pass. We formalize this tied-depth effect through a first-order perturbation bound controlled by a visit-alignment coefficient $\kappa_R$. The bound recovers the DeepNorm exponent when visits decorrelate, but in the conservative aligned regime it requires the exponent to increase from $1/4$ to $1/2$ as loop count grows at fixed physical depth. The resulting method, \textbf{DeepLoop}, keeps the Post-LN DeepNorm architecture and sets $\alpha=(2N)^{1/2}$ and $\beta=(8N)^{-1/2}$ for unrolled depth $N$. On GPT-style looped language models at GPT-2 small and GPT-2 medium scale, DeepLoop is neutral when no physical block is revisited and improves validation loss and downstream accuracy once recurrent depth is activated. These results show that stable recurrent depth requires residual scaling rules that account for parameter visits, not only nominal layer count.",Shuzhen Li; Yifan Zhang; Jiacheng Guo; Quanquan Gu; Mengdi Wang,2026-07-15,2026,arXiv,arXiv,,25 pages,cs.LG,arxiv-api,,,,,,,,,2607.13491,,2026-07-18T08:16:45+00:00
ale-0162,How Much Is One Recurrence Worth? Iso-Depth Scaling Laws for Looped Language Models,https://arxiv.org/abs/2604.21106,external,arxiv.org,ok,200,https://arxiv.org/abs/2604.21106,https://arxiv.org/abs/2604.21106,text/html; charset=utf-8,[2604.21106] How Much Is One Recurrence Worth? Iso-Depth Scaling Laws for Looped Language Models,"We measure how much one recurrence is worth to a looped (depth-recurrent) transformer, in equivalent unique parameters. From an iso-depth pretraining sweep across recurrence counts $r \in \{1, 2, 4, 8\}$ spanning ${\sim}50\times$ in training compute, we fit a joint scaling law $L = E + A\,(N_\text{once} + r^{\varphi} N_\text{rec})^{-\alpha} + B\,D^{-\beta}$ and measure a recurrence-equivalence exponent $\varphi = 0.46$. Intuitively, $\varphi$ tells us whether looping a block $r$ times is equivalent in validation loss to $r$ unique blocks of a non-looped model (full equivalence, $\varphi{=}1$) or to a single block run repeatedly with no capacity gain ($\varphi{=}0$). Our $\varphi = 0.46$ sits in between, so replacing unique blocks with shared recurrences increases validation loss at matched training compute. For example, at $r{=}4$ a 410M looped model performs on par with a 580M non-looped model, but incurs the training cost of a 1B non-looped one. We demonstrate the utility of $\varphi$ as a diagnostic tool on two case studies: commonly used truncated backpropagation lowers $\varphi$ to $0.38$, indicating that the loop mechanism is poorly trained under truncation, even though validation loss decreases. Conversely, hyperconnections raise $\varphi$ to $0.65$, a genuine capacity gain. Our method separates true loop improvements from training-side gains, a distinction raw validation loss cannot make.",Kristian Schwethelm; Daniel Rueckert; Georgios Kaissis,2026-04-22,2026,arXiv,arXiv,,v3: substantially refined framing + minor corrections v2: added case studies on truncated-BPTT and hyperconnections,cs.LG,arxiv-api,,,,,,,,,2604.21106,,2026-07-18T08:16:45+00:00
ale-0163,LoopCoder: Scaling Code Intelligence via Looped Language Models,https://aclanthology.org/2026.findings-acl.796/,external,aclanthology.org,ok,200,https://aclanthology.org/2026.findings-acl.796/,https://aclanthology.org/2026.findings-acl.796/,text/html; charset=utf-8,LoopCoder: Scaling Code Intelligence via Looped Language Models - ACL Anthology,"Jian Yang, Wei Zhang, Shuyue Guo, Yizhi LI, Linzheng Chai, Zhengmao Ye, Shukai Liu, Yuyang Song, Jiajun Wu, Che Liu, Tianyu Zheng, Siwei Wu, Leo L, Xudong Ma, Chuan Hao, Ran Tao, Yan Xing, Jianzhou Wang, Mingjie Tang, Aishan Liu, Zhoujun Li, Xianglong Liu, Weifeng Lv, Bryan Dai. Findings of the Association for Computational Linguistics: ACL 2026. 2026.",Jian Yang; Wei Zhang; Shuyue Guo; Yizhi Li; Linzheng Chai; Zhengmao Ye; Shukai Liu; Yuyang Song; Jiajun Wu; Che Liu; Tianyu Zheng; Siwei Wu; Leo L; Xudong Ma; Chuan Hao; Ran Tao; Yan Xing; Jianzhou Wang; Mingjie Tang; Aishan Liu; Zhoujun Li; Xianglong Liu; Weifeng Lv; Bryan Dai,2026,2026,Findings of the Association for Computational Linguistics: ACL 2026,ACL Anthology,10.18653/v1/2026.findings-acl.796,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0164,Looped World Models,https://arxiv.org/abs/2606.18208,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.18208,https://arxiv.org/abs/2606.18208,text/html; charset=utf-8,[2606.18208] Looped World Models,"Current world models face a fundamental tension: faithful long-horizon simulation demands deep computation, but deeper models are expensive to deploy and prone to compounding errors. We resolve this by introducing Looped World Models (LoopWM), which are the first looped architectures for world modelling. Our method iteratively refines latent environment states through a parameter-shared transformer block. This yield up to 100x parameter efficiency over conventional approaches with adaptive computation that automatically scales depth to match the complexity of each prediction step. Orthogonal to scaling model size and training data, LoopWM establishes iterative latent depth as a new scaling axis for world simulation, which might significantly push the community forward.",Hongyuan Adam Lu; Z. L. Victor Wei; Qun Zhang; Jinrui Zeng; Bowen Cao; Lingwei Meng; Mocheng Li; Zezhong Wang; Haonan Yin; Naifu Xue; Minyu Chen; Cenyuan Zhang; Zefan Zhang; Hao Wei; Jiawei Zhou; Haoran Xu; Hao Yang; Ronglai Zuo; Tongda Xu; Yonghao Li; Jian Chen; Hebin Wang; Zeyu Gao; Yang Li; Wei Zhao; Qimin Zhong; Siqi Liu; Yumeng Zhang; Leyan Cui; Zhangyu Wang; Wai Lam,2026-06-16,2026,arXiv,arXiv,,Technical Report,cs.LG,arxiv-api,,,,,,,,,2606.18208,,2026-07-18T08:16:45+00:00
ale-0165,Bridging the Gap Between Latent and Explicit Reasoning with Looped Transformers,https://arxiv.org/abs/2606.31779,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.31779,https://arxiv.org/abs/2606.31779,text/html; charset=utf-8,[2606.31779] Bridging the Gap Between Latent and Explicit Reasoning with Looped Transformers,"Language models typically reason via explicit chain-of-thought (CoT), generating intermediate steps token-by-token. Latent CoT offers an alternative: it performs multi-step reasoning in the model's hidden states, replacing decoded tokens with continuous representations for greater efficiency. However, existing latent CoT methods underperform explicit CoT beyond 1B parameters, and the gap widens with scale. Looped, or recurrent-depth, Transformers, which reuse their weights to increase computation depth without adding parameters, are a natural fit for latent reasoning. We therefore ask whether looped Transformers can bridge this gap. We answer affirmatively with a simple recipe: a looped padded Transformer that processes K latent blocks in parallel for R iterations, with a cross-entropy loss on each latent position's gold CoT-step token, similar to explicit CoT supervision. We instantiate it as LOTUS (Looped Transformers with parallel supervision on latents). LOTUS is, to our knowledge, the first latent-CoT method to bridge the gap to explicit CoT at the 3B scale, while cutting thought-phase latency by 2.5x-6.9x from compact math expressions to natural language. Projecting LOTUS's post-loop latents through the base LM head recovers the gold reasoning steps and even surfaces alternative valid intermediate steps, evidence that its latent space is interpretable and CoT-aligned. Ablations confirm that both the looped backbone and the parallel supervision on gold CoT tokens are essential. Code is available at https://github.com/yingfan-bot/lotus.",Ying Fan; Anej Svete; Kangwook Lee,2026-06-30,2026,arXiv,arXiv,,,cs.LG,arxiv-api,,,,,,,,,2606.31779,,2026-07-18T08:16:45+00:00
ale-0166,Looped SSMs: Depth-Recurrence and Input Reshaping for Time Series Classification,https://arxiv.org/abs/2605.16048,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.16048,https://arxiv.org/abs/2605.16048,text/html; charset=utf-8,[2605.16048] Looped SSMs: Depth-Recurrence and Input Reshaping for Time Series Classification,"State Space Models (SSMs) are inherently recurrent along the sequence dimension, yet depth-recurrence - reusing the same block repeatedly across layers, as recently applied in looped transformers - has not been explored in this model family. We show that a looped SSM with $k$ parameters iterated $L$ times consistently closely matches or outperforms a standard SSM with $k \cdot L$ independent parameters across four architectures (LRU, S5, LinOSS, LrcSSM) and six time series classification benchmarks, despite operating within a strictly smaller hypothesis space, as we formally establish. Since the larger model contains the looped model as a special case, this dominance cannot be explained by expressivity and instead points to parameter sharing across depth as a beneficial inductive bias that simplifies optimization. These results demonstrate that depth-recurrence is orthogonal to sequence-recurrence and independently beneficial. We further show that input reshaping is an equally neglected design axis: concatenating timesteps for low-dimensional inputs, or flattening and rechunking the joint feature-time dimension for high-dimensional ones, yields accuracy gains of 1-6% across all models, confirmed over 5 random seeds. Both techniques provide standalone improvements that compound when combined, suggesting that depth and input reshaping are two independent and underexplored design axes for SSMs on time series.",Mónika Farsang; Ramin Hasani; Daniela Rus; Radu Grosu,2026-05-15,2026,arXiv,arXiv,,,cs.LG,arxiv-api,,,,,,,,,2605.16048,,2026-07-18T08:16:45+00:00
ale-0167,Looped Diffusion Language Models,https://arxiv.org/abs/2605.26106,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.26106,https://arxiv.org/abs/2605.26106,text/html; charset=utf-8,[2605.26106] Looped Diffusion Language Models,"Masked diffusion models (MDMs) have emerged as a promising alternative to autoregressive models for language modeling, yet the effective design of transformer architectures for MDMs remains underexplored. In this paper, we show that selectively looping the early-middle transformer layers significantly improves both training efficiency and model performance in MDMs. We call this approach LoopMDM(Looped Masked Diffusion Model), which brings two key benefits: looping layers at training-time yields a depth-scaling effect without adding parameters, while varying the number of loops at inference-time enables flexible compute scaling. Despite the simplicity, the results are striking: across multiple pre-training corpora, LoopMDM matches the performance of same-size MDMs with up to 3.3 fewer training FLOPs, while its final performance outperforms them on various reasoning benchmarks, including up to 8.5 points on GSM8K. It even surpasses deeper non-looped MDMs trained with comparable per-step compute, indicating that selective looping is more effective than naive depth scaling. Furthermore, LoopMDM can scale inference-time compute by increasing the number of loops. Adaptively adjusting the number of loops throughout the sampling process further yields additional gains in compute efficiency while maintaining performance. Lastly, with attention analysis, we provide evidence that looping is effective in MDMs by promoting interactions among masked positions. Our code and weights will be publicly released.",Sanghyun Lee; Chunsan Hong; Seungryong Kim; Jonghyun Lee; Jongho Park; Dongmin Park,2026-05-25,2026,arXiv,arXiv,,23 pages,cs.LG,arxiv-api,,,,,,,,,2605.26106,,2026-07-18T08:16:45+00:00
ale-0168,Building Effective Agents,https://www.anthropic.com/engineering/building-effective-agents,external,www.anthropic.com,ok,200,https://www.anthropic.com/engineering/building-effective-agents,https://www.anthropic.com/engineering/building-effective-agents,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0169,"Harness Engineering for Language Agents: The Harness Layer as Control, Agency, and Runtime",https://www.preprints.org/manuscript/202603.1756,external,www.preprints.org,restricted,403,https://www.preprints.org/manuscript/202603.1756,https://www.preprints.org/manuscript/202603.1756,text/html,,,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,,,,,,,,,,restricted_or_rate_limited,2026-07-18T08:16:45+00:00
ale-0170,How we built our multi-agent research system,https://www.anthropic.com/engineering/multi-agent-research-system,external,www.anthropic.com,ok,200,https://www.anthropic.com/engineering/multi-agent-research-system,https://www.anthropic.com/engineering/multi-agent-research-system,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0171,Building Effective AI Agents: Architecture Patterns and Implementation Frameworks,https://resources.anthropic.com/hubfs/Building%20Effective%20AI%20Agents-%20Architecture%20Patterns%20and%20Implementation%20Frameworks.pdf,external,resources.anthropic.com,ok,200,https://resources.anthropic.com/hubfs/Building%20Effective%20AI%20Agents-%20Architecture%20Patterns%20and%20Implementation%20Frameworks.pdf,https://resources.anthropic.com/hubfs/Building%20Effective%20AI%20Agents-%20Architecture%20Patterns%20and%20Implementation%20Frameworks.pdf,application/pdf,,,Anthropic,2025-12-03,2025,Anthropic eBook,Anthropic,,Date verified from the primary PDF creation metadata.,,pdf-metadata,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0172,AI Agent Architectures,https://hld.handbook.academy/curriculum/ai-ml-system-design/ai-agent-architectures/,external,hld.handbook.academy,ok,200,https://hld.handbook.academy/curriculum/ai-ml-system-design/ai-agent-architectures/,https://hld.handbook.academy/curriculum/ai-ml-system-design/ai-agent-architectures/,text/html; charset=utf-8,"AI Agent Architectures (ReAct, Reflection, Planning, Tool Use, Memory) - The HLD Handbook","The canonical patterns for turning an LLM into an agent: ReAct's think-act-observe loop, reflection and self-critique, planner-executor decomposition, tool use and function calling, and how agents manage short- and long-term memory.",,,,,The HLD Handbook,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0173,What Are Agentic Workflows?,https://weaviate.io/blog/what-are-agentic-workflows,external,weaviate.io,ok,200,https://weaviate.io/blog/what-are-agentic-workflows,https://weaviate.io/blog/what-are-agentic-workflows,text/html; charset=UTF-8,"What Are Agentic Workflows? Patterns, Memory, Use Cases, and Examples | Weaviate","Agentic workflows combine AI agents, tools, and agent memory to create adaptive systems. Learn the core patterns, use cases, and real-world examples.",,2025-03-06,2025,,weaviate.io,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0174,Agent Planning & Reflection Patterns,https://learnaivisually.com/tracks/ai-agents/planning-reflection,external,learnaivisually.com,ok,200,https://learnaivisually.com/tracks/ai-agents/planning-reflection,https://learnaivisually.com/tracks/ai-agents/planning-reflection,text/html; charset=utf-8,Agent Planning & Reflection Patterns | Learn AI Visually LAV LAV,"When agents should plan, retry, pause, or stop. Reasoning budget, ReAct, Reflexion, and termination logic — each tied to a 'when' decision.",,,,,Learn AI Visually,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0175,Agentic Design Patterns,https://addyosmani.com/agents/04-agentic-design-patterns/,external,addyosmani.com,ok,200,https://addyosmani.com/agents/04-agentic-design-patterns/,https://addyosmani.com/agents/04-agentic-design-patterns/,text/html; charset=UTF-8,AddyOsmani.com - Lesson 4: agentic design patterns,"Addy Osmani is an engineering and evangelism leader who spent over 14 years at Google leading developer experience across Chrome and, in recent years, AI (Gemini, coding agents, and agentic engineering), most recently as a Director at Google Cloud AI.",Addy Osmani,,,,addyosmani.com,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0176,12 Factor Agents,https://github.com/humanlayer/12-factor-agents,external,github.com,ok,200,https://github.com/humanlayer/12-factor-agents,https://github.com/humanlayer/12-factor-agents,text/html; charset=utf-8,GitHub - humanlayer/12-factor-agents: What are the principles we can use to build LLM-powered software that is actually good enough to put in the hands of production customers? · GitHub,What are the principles we can use to build LLM-powered software that is actually good enough to put in the hands of production customers? - humanlayer/12-factor-agents,,2025-03-30,2025,humanlayer/12-factor-agents,GitHub,,,,github-api,humanlayer/12-factor-agents,24377,1849,26,What are the principles we can use to build LLM-powered software that is actually good enough to put in the hands of production customers?,NOASSERTION,2025-03-30T22:10:39Z,2026-07-18T07:40:09Z,,,2026-07-18T08:16:45+00:00
ale-0177,Durable Execution for Agentic Workflows,https://arizenai.com/durable-execution/,external,arizenai.com,ok,200,https://arizenai.com/durable-execution/,https://arizenai.com/durable-execution/,text/html; charset=utf-8,Durable Execution for Agentic Workflows | Arizen,A while loop is at-most-once across process boundaries. Production agents need exactly-once. The architecture must encode the guarantee.,,2026-03-30,2026,,Arizen,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0178,Code as Agent Harness,https://arxiv.org/abs/2605.18747,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.18747,https://arxiv.org/abs/2605.18747,text/html; charset=utf-8,[2605.18747] Code as Agent Harness,"Recent large language models (LLMs) have demonstrated strong capabilities in understanding and generating code, from competitive programming to repository-level software engineering. In emerging agentic systems, code is no longer only a target output. It increasingly serves as an operational substrate for agent reasoning, acting, environment modeling, and execution-based verification. We frame this shift through the lens of agent harnesses and introduce code as agent harness: a unified view that centers code as the basis for agent infrastructure. To systematically study this perspective, we organize the survey around three connected layers. First, we study the harness interface, where code connects agents to reasoning, action, and environment modeling. Second, we examine harness mechanisms: planning, memory, and tool use for long-horizon execution, together with feedback-driven control and optimization that make harness reliable and adaptive. Third, we discuss scaling the harness from single-agent systems to multi-agent settings, where shared code artifacts support multi-agent coordination, review, and verification. Across these layers, we summarize representative methods and practical applications of code as agent harness, spanning coding assistants, GUI/OS automation, embodied agents, scientific discovery, personalization and recommendation, DevOps, and enterprise workflows. We further outline open challenges for harness engineering, including evaluation beyond final task success, verification under incomplete feedback, regression-free harness improvement, consistent shared state across multiple agents, human oversight for safety-critical actions, and extensions to multimodal environments. By centering code as the harness of agentic AI, this survey provides a unified roadmap toward executable, verifiable, and stateful AI agent systems.",Xuying Ning; Katherine Tieu; Dongqi Fu; Tianxin Wei; Zihao Li; Yuanchen Bei; Jiaru Zou; Mengting Ai; Zhining Liu; Ting-Wei Li; Lingjie Chen; Yanjun Zhao; Ke Yang; Bingxuan Li; Cheng Qian; Gaotang Li; Xiao Lin; Zhichen Zeng; Ruizhong Qiu; Sirui Chen; Yifan Sun; Xiyuan Yang; Ruida Wang; Rui Pan; Chenyuan Yang; Dylan Zhang; Liri Fang; Zikun Cui; Yang Cao; Pan Chen; Dorothy Sun; Ren Chen; Mahesh Srinivasan; Nipun Mathur; Yinglong Xia; Hong Li; Hong Yan; Pan Lu; Lingming Zhang; Tong Zhang; Hanghang Tong; Jingrui He,2026-05-18,2026,arXiv,arXiv,,GitHub: https://github.com/YennNing/Awesome-Code-as-Agent-Harness-Papers,cs.CL,arxiv-api,,,,,,,,,2605.18747,,2026-07-18T08:16:45+00:00
ale-0179,Agentic Agile-V: From Vibe Coding to Verified Engineering,https://arxiv.org/abs/2605.20456,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.20456,https://arxiv.org/abs/2605.20456,text/html; charset=utf-8,[2605.20456] Agentic Agile-V: From Vibe Coding to Verified Engineering in Software and Hardware Development,"Agentic AI coding systems can inspect repositories, plan implementation steps, edit files, call tools, run tests, and submit pull requests. These capabilities make software and hardware development faster in some settings, but current evidence does not support the simple claim that autonomous code generation automatically improves engineering outcomes. Controlled studies report productivity gains in some enterprise tasks, slowdowns in mature open-source work, moderate but heterogeneous meta-analytic effects, and persistent failures in repository setup, dependency handling, permission gating, and hardware verification. This paper argues that the central problem is no longer prompt engineering; it is engineering process control. It synthesizes evidence from agentic software engineering, GitHub-scale adoption studies, repository-level agent configuration, productivity trials, issue-resolution benchmarks, and hardware/RTL verification research. It proposes Agentic Agile-V, a process framework that uses Agile-V as the lifecycle backbone and a task-level SCOPE-V loop - Specify, Constrain, Orchestrate, Prove, Evolve, and Verify - to convert conversational intent into structured engineering artifacts and acceptance evidence. The paper contributes: (i) a taxonomy of minimum input artifacts for agentic software, firmware, and hardware work; (ii) a conversation-to-contract gate that separates exploratory dialogue from implementation; (iii) risk-adaptive feature, bug-fix, testing, and hardware workflows; and (iv) an evidence-bundle acceptance model for agent-generated artifacts. The paper concludes that agentic AI does not eliminate engineering discipline; it increases the value of requirements, constraints, traceability, independent verification, and human approval.",Christopher Koch,2026-05-19,2026,arXiv,arXiv,,"7 pages, 1 figure",cs.SE,arxiv-api,,,,,,,,,2605.20456,,2026-07-18T08:16:45+00:00
ale-0180,Agentic Software Engineering: Foundational Pillars and a Research Roadmap,https://arxiv.org/abs/2509.06216,external,arxiv.org,ok,200,https://arxiv.org/abs/2509.06216,https://arxiv.org/abs/2509.06216,text/html; charset=utf-8,[2509.06216] Agentic Software Engineering: Foundational Pillars and a Research Roadmap,"Agentic Software Engineering (SE 3.0) represents a new era where intelligent agents are tasked not with simple code generation, but with achieving complex, goal-oriented SE objectives. To harness these new capabilities while ensuring trustworthiness, we must recognize a fundamental duality within the SE field in the Agentic SE era, comprising two symbiotic modalities: SE for Humans and SE for Agents. This duality demands a radical reimagining of the foundational pillars of SE (actors, processes, tools, and artifacts) which manifest differently across each modality. We propose two purpose-built workbenches to support this vision. The Agent Command Environment (ACE) serves as a command center where humans orchestrate and mentor agent teams, handling outputs such as Merge-Readiness Packs (MRPs) and Consultation Request Packs (CRPs). The Agent Execution Environment (AEE) is a digital workspace where agents perform tasks while invoking human expertise when facing ambiguity or complex trade-offs. This bi-directional partnership, which supports agent-initiated human callbacks and handovers, gives rise to new, structured engineering activities (i.e., processes) that redefine human-AI collaboration, elevating the practice from agentic coding to true agentic software engineering. This paper presents the Structured Agentic Software Engineering (SASE) vision, outlining several of the foundational pillars for the future of SE. The paper culminates in a research roadmap that identifies a few key challenges and opportunities while briefly discussing the resulting impact of this future on SE education. Our goal is not to offer a definitive solution, but to provide a conceptual scaffold with structured vocabulary to catalyze a community-wide dialogue, pushing the SE community to think beyond its classic, human-centric tenets toward a disciplined, scalable, and trustworthy agentic future.",Ahmed E. Hassan; Hao Li; Dayi Lin; Bram Adams; Tse-Hsun Chen; Yutaro Kashiwa; Dong Qiu,2025-09-07,2025,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,,,2509.06216,,2026-07-18T08:16:45+00:00
ale-0181,The Art of Loop Engineering,https://www.langchain.com/blog/the-art-of-loop-engineering,external,www.langchain.com,ok,200,https://www.langchain.com/blog/the-art-of-loop-engineering,https://www.langchain.com/blog/the-art-of-loop-engineering,text/html; charset=utf-8,The Art of Loop Engineering,"Agents automate real-world work, but reliable performance requires more than a good model, it requires a carefully designed harness built for specific tasks. This post explores the core agent loop, how stacking and extending loops builds more effective agents, and how to instrument each level with LangChain primitives.",,,,,LangChain,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0182,Loopy,https://github.com/Forward-Future/loopy,external,github.com,ok,200,https://github.com/Forward-Future/loopy,https://github.com/Forward-Future/loopy,text/html; charset=utf-8,"GitHub - Forward-Future/loopy: A library of practical AI-agent loops and an installable skill for finding, adapting, and designing repeatable agent workflows. · GitHub","A library of practical AI-agent loops and an installable skill for finding, adapting, and designing repeatable agent workflows. - Forward-Future/loopy",,2026-06-12,2026,Forward-Future/loopy,GitHub,,,,github-api,Forward-Future/loopy,2749,242,1,"A library of practical AI-agent loops and an installable skill for finding, adapting, and designing repeatable agent workflows.",MIT,2026-06-12T14:44:22Z,2026-07-18T07:58:54Z,,,2026-07-18T08:16:45+00:00
ale-0183,The Factory Model: How Coding Agents Changed Software Engineering,https://addyosmani.com/blog/factory-model/,external,addyosmani.com,ok,200,https://addyosmani.com/blog/factory-model/,https://addyosmani.com/blog/factory-model/,text/html; charset=UTF-8,AddyOsmani.com - The Factory Model: How Coding Agents Changed Software Engineering,Software engineering is not about writing code anymore. It is about building the factory that builds your software.,Addy Osmani,,,,addyosmani.com,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0184,2026 Agentic Coding Trends Report,https://resources.anthropic.com/2026-agentic-coding-trends-report,external,resources.anthropic.com,ok,200,https://resources.anthropic.com/2026-agentic-coding-trends-report,https://resources.anthropic.com/2026-agentic-coding-trends-report,text/html; charset=UTF-8,2026 Agentic Coding Trends Report,"How coding agents are transforming software development - and what it means for engineering teams in 2026. Insights on multi-agent systems, human-AI collaboration, and scaling agentic coding across organizations. Includes case studies from Rakuten, TELUS, Zapier, and more.",,,2026,,Anthropic,,,,url-date,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0185,HomeRail,https://github.com/xiaotianfotos/homerail,external,github.com,ok,200,https://github.com/xiaotianfotos/homerail,https://github.com/xiaotianfotos/homerail,text/html; charset=utf-8,GitHub - xiaotianfotos/homerail: Voice-first local agent orchestration runtime for auditable DAG workflows. · GitHub,Voice-first local agent orchestration runtime for auditable DAG workflows. - xiaotianfotos/homerail,,2026-07-07,2026,xiaotianfotos/homerail,GitHub,,,,github-api,xiaotianfotos/homerail,614,135,13,Voice-first local agent orchestration runtime for auditable DAG workflows.,MIT,2026-07-07T12:11:18Z,2026-07-18T08:00:51Z,,,2026-07-18T08:16:45+00:00
ale-0186,"Old and New Apps, via Modern Coding Agents",https://terrytao.wordpress.com/2026/07/11/old-and-new-apps-via-modern-coding-agents/,external,terrytao.wordpress.com,ok,200,https://terrytao.wordpress.com/2026/07/11/old-and-new-apps-via-modern-coding-agents/,https://terrytao.wordpress.com/2026/07/11/old-and-new-apps-via-modern-coding-agents/,text/html; charset=UTF-8,"Old and new apps, via modern coding agents | What's new","I have been interested in machine-assisted ways to do and teach mathematics from as far back as 1999, when I started coding several applets in Java 1.0, both for my complex analysis and linear alge…",,2026-07-11,2026,,What's new,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0187,"Harness Handbook: Making Evolving Agent Harnesses Readable,Navigable, and Editable",https://arxiv.org/abs/2607.13285,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.13285,https://arxiv.org/abs/2607.13285,text/html; charset=utf-8,"[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-18T08:16:45+00:00
ale-0188,MemoHarness: Agent Harnesses That Learn from Experience,https://arxiv.org/abs/2607.14159,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14159,https://arxiv.org/abs/2607.14159,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0189,SWE-agent,https://github.com/SWE-agent/SWE-agent,external,github.com,ok,200,https://github.com/SWE-agent/SWE-agent,https://github.com/SWE-agent/SWE-agent,text/html; charset=utf-8,"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,19840,2168,43,"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]",MIT,2024-04-02T04:09:47Z,2026-07-17T20:37:03Z,,,2026-07-18T08:16:45+00:00
ale-0190,SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering,https://arxiv.org/abs/2405.15793,external,arxiv.org,ok,200,https://arxiv.org/abs/2405.15793,https://proceedings.neurips.cc/paper_files/paper/2024/hash/5a7c947568c1b1328ccc5230172e1e7c-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0191,mini-SWE-agent,https://mini-swe-agent.com/latest/,external,mini-swe-agent.com,ok,200,https://mini-swe-agent.com/latest/,https://mini-swe-agent.com/latest/,text/html; charset=utf-8,Overview - mini-SWE-agent documentation,,,,,,mini-swe-agent.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0192,OpenHands,https://github.com/All-Hands-AI/OpenHands,external,github.com,ok,200,https://github.com/OpenHands/OpenHands,https://github.com/OpenHands/OpenHands,text/html; charset=utf-8,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,81153,10375,369,🙌 OpenHands: AI-Driven Development,NOASSERTION,2024-03-13T03:33:31Z,2026-07-18T07:54:50Z,,,2026-07-18T08:16:45+00:00
ale-0193,OpenHands: An Open Platform for AI Software Developers as Generalist Agents,https://arxiv.org/abs/2407.16741,external,arxiv.org,ok,200,https://arxiv.org/abs/2407.16741,https://proceedings.iclr.cc/paper_files/paper/2025/hash/a4b6ad6b48850c0c331d1259fc66a69c-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0194,Agentless,https://github.com/OpenAutoCoder/Agentless,external,github.com,ok,200,https://github.com/OpenAutoCoder/Agentless,https://github.com/OpenAutoCoder/Agentless,text/html; charset=utf-8,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,54,Agentless🐱: an agentless approach to automatically solve software development problems,MIT,2024-06-30T23:37:17Z,2026-07-16T06:42:42Z,,,2026-07-18T08:16:45+00:00
ale-0195,Agentless: Demystifying LLM-based Software Engineering Agents,https://arxiv.org/abs/2407.01489,external,arxiv.org,ok,200,https://arxiv.org/abs/2407.01489,https://arxiv.org/abs/2407.01489,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0196,AutoCodeRover,https://github.com/AutoCodeRoverSG/auto-code-rover,external,github.com,ok,200,https://github.com/AutoCodeRoverSG/auto-code-rover,https://github.com/AutoCodeRoverSG/auto-code-rover,text/html; charset=utf-8,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,20,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.,NOASSERTION,2024-04-08T05:34:14Z,2026-07-14T08:02:04Z,,,2026-07-18T08:16:45+00:00
ale-0197,AutoCodeRover: Autonomous Program Improvement,https://arxiv.org/abs/2404.05427,external,arxiv.org,ok,200,https://arxiv.org/abs/2404.05427,https://doi.org/10.1145/3650212.3680384,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0198,SWE-bench reading list,https://github.com/SWE-bench/reading-list,external,github.com,ok,200,https://github.com/SWE-bench/reading-list,https://github.com/SWE-bench/reading-list,text/html; charset=utf-8,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,0,Academic papers and works related to SWE-bench and SWE-agents,,2025-06-26T22:03:02Z,2026-06-30T13:06:47Z,,,2026-07-18T08:16:45+00:00
ale-0199,TraceCoder: A Trace-Driven Multi-Agent Framework for Automated Debugging of LLM-Generated Code,https://arxiv.org/abs/2602.06875,external,arxiv.org,ok,200,https://arxiv.org/abs/2602.06875,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,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0200,The Kitchen Loop: User-Spec-Driven Development for a Self-Evolving Codebase,https://arxiv.org/abs/2603.25697,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.25697,https://arxiv.org/abs/2603.25697,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0201,Inside the Scaffold: A Source-Code Taxonomy of Coding Agent Architectures,https://arxiv.org/abs/2604.03515,external,arxiv.org,ok,200,https://arxiv.org/abs/2604.03515,https://arxiv.org/abs/2604.03515,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0202,A Self-Improving Coding Agent,https://arxiv.org/abs/2504.15228,external,arxiv.org,ok,200,https://arxiv.org/abs/2504.15228,https://arxiv.org/abs/2504.15228,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0203,Don't Blame the Large Language Model: How Scaffolding Evolution Shapes Coding Agent Quality,https://arxiv.org/abs/2607.03691,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.03691,https://arxiv.org/abs/2607.03691,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0204,"ToFu: A White-Box, Token-Efficient Agent Harness for Researchers",https://arxiv.org/abs/2607.11423,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.11423,https://arxiv.org/abs/2607.11423,text/html; charset=utf-8,"[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-18T08:16:45+00:00
ale-0205,When Does Restricting a Coding Agent to execute_code Help?,https://arxiv.org/abs/2607.10569,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.10569,https://arxiv.org/abs/2607.10569,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0206,Ralph,https://ghuntley.com/ralph/,external,ghuntley.com,ok,200,https://ghuntley.com/ralph/,https://ghuntley.com/ralph/,text/html; charset=utf-8,"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-18T08:16:45+00:00
ale-0207,everything is a ralph loop,https://ghuntley.com/loop/,external,ghuntley.com,ok,200,https://ghuntley.com/loop/,https://ghuntley.com/loop/,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0208,how-to-ralph-wiggum,https://github.com/ghuntley/how-to-ralph-wiggum,external,github.com,ok,200,https://github.com/ghuntley/how-to-ralph-wiggum,https://github.com/ghuntley/how-to-ralph-wiggum,text/html; charset=utf-8,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,1,The Ralph Wiggum Technique—the AI development methodology that reduces software costs to less than a fast food worker's wage.,,2026-01-10T04:32:01Z,2026-07-17T13:23:53Z,,,2026-07-18T08:16:45+00:00
ale-0209,A Brief History of Ralph,https://www.humanlayer.dev/blog/brief-history-of-ralph,external,www.humanlayer.dev,ok,200,https://www.humanlayer.dev/blog/brief-history-of-ralph,https://www.humanlayer.dev/blog/brief-history-of-ralph,text/html; charset=utf-8,A Brief History of Ralph | HumanLayer Blog,The Ralph Wiggum Technique went viral in the last week of 2025. Here's the story of ralph since the first time I met Geoff in June of 2025.,,2026,2026,,humanlayer.dev,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0210,Ralph Copilot,https://github.com/giocaizzi/ralph-copilot/tree/e5b2813cc876c73a8c9d3398c0115da0d15f63cf,external,github.com,ok,200,https://github.com/giocaizzi/ralph-copilot/tree/e5b2813cc876c73a8c9d3398c0115da0d15f63cf,https://github.com/giocaizzi/ralph-copilot/tree/e5b2813cc876c73a8c9d3398c0115da0d15f63cf,text/html; charset=utf-8,GitHub - giocaizzi/ralph-copilot at e5b2813cc876c73a8c9d3398c0115da0d15f63cf · GitHub,Copilot implementation of Ralph loop. Contribute to giocaizzi/ralph-copilot development by creating an account on GitHub.,,2026-01-30,2026,giocaizzi/ralph-copilot,GitHub,,,,github-api,giocaizzi/ralph-copilot,138,16,0,Copilot implementation of Ralph loop,,2026-01-30T11:25:36Z,2026-07-16T14:18:20Z,,,2026-07-18T08:16:45+00:00
ale-0211,Ralph (snarktank),https://github.com/snarktank/ralph,external,github.com,ok,200,https://github.com/snarktank/ralph,https://github.com/snarktank/ralph,text/html; charset=utf-8,GitHub - snarktank/ralph: Ralph is an autonomous AI agent loop that runs repeatedly until all PRD items are complete. · GitHub,Ralph is an autonomous AI agent loop that runs repeatedly until all PRD items are complete. - GitHub - snarktank/ralph: Ralph is an autonomous AI agent loop that runs repeatedly until all PRD items are complete.,,2026-01-07,2026,snarktank/ralph,GitHub,,,,github-api,snarktank/ralph,21117,2045,74,Ralph is an autonomous AI agent loop that runs repeatedly until all PRD items are complete.,MIT,2026-01-07T14:45:10Z,2026-07-18T07:54:03Z,,,2026-07-18T08:16:45+00:00
ale-0212,ralph-claude-code,https://github.com/frankbria/ralph-claude-code,external,github.com,ok,200,https://github.com/frankbria/ralph-claude-code,https://github.com/frankbria/ralph-claude-code,text/html; charset=utf-8,GitHub - frankbria/ralph-claude-code: Autonomous AI development loop for Claude Code with intelligent exit detection · GitHub,Autonomous AI development loop for Claude Code with intelligent exit detection - frankbria/ralph-claude-code,,2025-08-27,2025,frankbria/ralph-claude-code,GitHub,,,,github-api,frankbria/ralph-claude-code,9546,729,28,Autonomous AI development loop for Claude Code with intelligent exit detection,MIT,2025-08-27T16:03:45Z,2026-07-18T07:53:46Z,,,2026-07-18T08:16:45+00:00
ale-0213,ralph-orchestrator,https://github.com/mikeyobrien/ralph-orchestrator,external,github.com,ok,200,https://github.com/mikeyobrien/ralph-orchestrator,https://github.com/mikeyobrien/ralph-orchestrator,text/html; charset=utf-8,GitHub - mikeyobrien/ralph-orchestrator: An improved implementation of the Ralph Wiggum technique for autonomous AI agent orchestration · GitHub,An improved implementation of the Ralph Wiggum technique for autonomous AI agent orchestration - mikeyobrien/ralph-orchestrator,,2025-09-07,2025,mikeyobrien/ralph-orchestrator,GitHub,,,,github-api,mikeyobrien/ralph-orchestrator,3031,286,10,An improved implementation of the Ralph Wiggum technique for autonomous AI agent orchestration,MIT,2025-09-07T18:17:13Z,2026-07-18T07:50:06Z,,,2026-07-18T08:16:45+00:00
ale-0214,ralphex,https://github.com/umputun/ralphex,external,github.com,ok,200,https://github.com/umputun/ralphex,https://github.com/umputun/ralphex,text/html; charset=utf-8,GitHub - umputun/ralphex: Extended Ralph loop for autonomous AI-driven plan execution · GitHub,Extended Ralph loop for autonomous AI-driven plan execution - umputun/ralphex,,2026-01-19,2026,umputun/ralphex,GitHub,,,,github-api,umputun/ralphex,1384,113,9,Extended Ralph loop for autonomous AI-driven plan execution,MIT,2026-01-19T22:44:35Z,2026-07-18T08:13:52Z,,,2026-07-18T08:16:45+00:00
ale-0215,ralph (iannuttall),https://github.com/iannuttall/ralph,external,github.com,ok,200,https://github.com/iannuttall/ralph,https://github.com/iannuttall/ralph,text/html; charset=utf-8,"GitHub - iannuttall/ralph: A minimal, file‑based agent loop for autonomous coding. · GitHub","A minimal, file‑based agent loop for autonomous coding. - iannuttall/ralph",,2026-01-12,2026,iannuttall/ralph,GitHub,,,,github-api,iannuttall/ralph,932,91,9,"A minimal, file‑based agent loop for autonomous coding.",,2026-01-12T15:31:06Z,2026-07-11T16:27:54Z,,,2026-07-18T08:16:45+00:00
ale-0216,ralph-loop-agent,https://github.com/vercel-labs/ralph-loop-agent,external,github.com,ok,200,https://github.com/vercel-labs/ralph-loop-agent,https://github.com/vercel-labs/ralph-loop-agent,text/html; charset=utf-8,GitHub - vercel-labs/ralph-loop-agent: Continuous Autonomy for the AI SDK · GitHub,Continuous Autonomy for the AI SDK. Contribute to vercel-labs/ralph-loop-agent development by creating an account on GitHub.,,2026-01-03,2026,vercel-labs/ralph-loop-agent,GitHub,,,,github-api,vercel-labs/ralph-loop-agent,821,86,2,Continuous Autonomy for the AI SDK,Apache-2.0,2026-01-03T21:18:55Z,2026-07-16T19:00:19Z,,,2026-07-18T08:16:45+00:00
ale-0217,Open Ralph Wiggum,https://github.com/Th0rgal/open-ralph-wiggum,external,github.com,ok,200,https://github.com/Th0rgal/open-ralph-wiggum,https://github.com/Th0rgal/open-ralph-wiggum,text/html; charset=utf-8,"GitHub - Th0rgal/open-ralph-wiggum: Type `ralph ""prompt""` to start open code in a ralph loop. Also supports a prompt file & status check. Open Code, Claude Code, Codex, Copilot · GitHub","Type `ralph ""prompt""` to start open code in a ralph loop. Also supports a prompt file & status check. Open Code, Claude Code, Codex, Copilot - Th0rgal/open-ralph-wiggum",,2026-01-06,2026,Th0rgal/open-ralph-wiggum,GitHub,,,,github-api,Th0rgal/open-ralph-wiggum,1843,142,8,"Type `ralph ""prompt""` to start open code in a ralph loop. Also supports a prompt file & status check. Open Code, Claude Code, Codex, Copilot",MIT,2026-01-06T08:06:47Z,2026-07-18T08:07:34Z,,,2026-07-18T08:16:45+00:00
ale-0218,Compound Engineering,https://every.to/guides/compound-engineering,external,every.to,ok,200,https://every.to/guides/compound-engineering,https://every.to/guides/compound-engineering,text/html; charset=utf-8,Compound Engineering - Every,The AI-native engineering philosophy,,,,,every.to,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0219,Gas Town,https://github.com/steveyegge/gastown,external,github.com,ok,200,https://github.com/gastownhall/gastown,https://github.com/gastownhall/gastown,text/html; charset=utf-8,GitHub - gastownhall/gastown: Gas Town - multi-agent workspace manager · GitHub,Gas Town - multi-agent workspace manager. Contribute to gastownhall/gastown development by creating an account on GitHub.,,2025-12-16,2025,steveyegge/gastown,GitHub,,,,github-api,steveyegge/gastown,17084,1572,269,Gas Town - multi-agent workspace manager,MIT,2025-12-16T00:33:33Z,2026-07-18T02:59:49Z,,,2026-07-18T08:16:45+00:00
ale-0220,Amp,https://ampcode.com/,external,ampcode.com,ok,200,https://ampcode.com/,https://ampcode.com/,text/html,Amp,Amp is a frontier coding agent that lets you wield the full power of leading models.,,,,,ampcode.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0221,karl,https://github.com/kayoslab/karl,external,github.com,ok,200,https://github.com/kayoslab/karl,https://github.com/kayoslab/karl,text/html; charset=utf-8,GitHub - kayoslab/karl: Autonomous multi-agent development loop · GitHub,Autonomous multi-agent development loop. Contribute to kayoslab/karl development by creating an account on GitHub.,,2026-03-10,2026,kayoslab/karl,GitHub,,,,github-api,kayoslab/karl,0,0,0,Autonomous multi-agent development loop,MIT,2026-03-10T09:50:32Z,2026-04-08T07:56:55Z,,,2026-07-18T08:16:45+00:00
ale-0222,joelclaw agent-loop skill,https://github.com/joelhooks/joelclaw/blob/main/skills/agent-loop/SKILL.md,external,github.com,ok,200,https://github.com/joelhooks/joelclaw/blob/main/skills/agent-loop/SKILL.md,https://github.com/joelhooks/joelclaw/blob/main/skills/agent-loop/SKILL.md,text/html; charset=utf-8,joelclaw/skills/agent-loop/SKILL.md at main · joelhooks/joelclaw · GitHub,"Personal AI operating system — blog, architecture decisions, and the journey from zero to a composable agent system. - joelclaw/skills/agent-loop/SKILL.md at main · joelhooks/joelclaw",,2026-02-14,2026,joelhooks/joelclaw,GitHub,,,,github-api,joelhooks/joelclaw,61,3,14,"Personal AI operating system — blog, architecture decisions, and the journey from zero to a composable agent system.",,2026-02-14T22:54:08Z,2026-07-18T01:32:09Z,,,2026-07-18T08:16:45+00:00
ale-0223,ARIS (Auto-Research-In-Sleep),https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep,external,github.com,ok,200,https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep,https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep,text/html; charset=utf-8,"GitHub - wanshuiyin/Auto-claude-code-research-in-sleep: ARIS ⚔️ (Auto-Research-In-Sleep) — Lightweight Markdown-only skills for autonomous ML research: cross-model review loops, idea discovery, and experiment automation. No framework, no lock-in — works with Claude Code, Codex, OpenClaw, or any LLM agent. · GitHub","ARIS ⚔️ (Auto-Research-In-Sleep) — Lightweight Markdown-only skills for autonomous ML research: cross-model review loops, idea discovery, and experiment automation. No framework, no lock-in — works with Claude Code, Codex, OpenClaw, or any LLM agent. - wanshuiyin/Auto-claude-code-research-in-sleep",,2026-03-10,2026,wanshuiyin/Auto-claude-code-research-in-sleep,GitHub,,,,github-api,wanshuiyin/Auto-claude-code-research-in-sleep,13538,1220,59,"ARIS ⚔️ (Auto-Research-In-Sleep) — Lightweight Markdown-only skills for autonomous ML research: cross-model review loops, idea discovery, and experiment automation. No framework, no lock-in — works with Claude Code, Codex, OpenClaw, or any LLM agent.",MIT,2026-03-10T07:31:45Z,2026-07-18T07:48:49Z,,,2026-07-18T08:16:45+00:00
ale-0224,AutoAgent,https://github.com/kevinrgu/autoagent,external,github.com,ok,200,https://github.com/kevinrgu/autoagent,https://github.com/kevinrgu/autoagent,text/html; charset=utf-8,GitHub - kevinrgu/autoagent: autonomous harness engineering · GitHub,autonomous harness engineering. Contribute to kevinrgu/autoagent development by creating an account on GitHub.,,2026-04-02,2026,kevinrgu/autoagent,GitHub,,,,github-api,kevinrgu/autoagent,4544,498,8,autonomous harness engineering,,2026-04-02T20:44:58Z,2026-07-17T16:17:16Z,,,2026-07-18T08:16:45+00:00
ale-0225,zeroshot,https://github.com/the-open-engine/zeroshot,external,github.com,ok,200,https://github.com/the-open-engine/zeroshot,https://github.com/the-open-engine/zeroshot,text/html; charset=utf-8,"GitHub - the-open-engine/zeroshot: Your autonomous engineering team in a CLI. The agent loop produces senior-level code that you can actually trust in prod because of non-negotiable feedback from independent reviewers. Supports Claude Code, OpenAI Codex, OpenCode, and Gemini CLI with trivial setup. · GitHub","Your autonomous engineering team in a CLI. The agent loop produces senior-level code that you can actually trust in prod because of non-negotiable feedback from independent reviewers. Supports Claude Code, OpenAI Codex, OpenCode, and Gemini CLI with trivial setup. - the-open-engine/zeroshot",,2025-12-25,2025,the-open-engine/zeroshot,GitHub,,,,github-api,the-open-engine/zeroshot,1647,141,105,"Your autonomous engineering team in a CLI. The agent loop produces senior-level code that you can actually trust in prod because of non-negotiable feedback from independent reviewers. Supports Claude Code, OpenAI Codex, OpenCode, and Gemini CLI with trivial setup.",MIT,2025-12-25T17:12:45Z,2026-07-17T21:19:55Z,,,2026-07-18T08:16:45+00:00
ale-0226,Loki Mode,https://github.com/asklokesh/loki-mode,external,github.com,ok,200,https://github.com/asklokesh/loki-mode,https://github.com/asklokesh/loki-mode,text/html; charset=utf-8,"GitHub - asklokesh/loki-mode: Multi-agent autonomous SDLC framework. Spec to deployed app. PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief. 5 AI providers, 8 quality gates. · GitHub","Multi-agent autonomous SDLC framework. Spec to deployed app. PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief. 5 AI providers, 8 quality gates. - asklokesh/loki-mode",,2025-12-26,2025,asklokesh/loki-mode,GitHub,,,,github-api,asklokesh/loki-mode,1022,199,4,"Multi-agent autonomous SDLC framework. Spec to deployed app. PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief. 5 AI providers, 8 quality gates.",NOASSERTION,2025-12-26T16:26:14Z,2026-07-18T02:04:47Z,,,2026-07-18T08:16:45+00:00
ale-0227,Looper,https://github.com/ksimback/looper,external,github.com,ok,200,https://github.com/ksimback/looper,https://github.com/ksimback/looper,text/html; charset=utf-8,"GitHub - ksimback/looper: Design visual, review-gated agent loops for Claude Code before you run them. · GitHub","Design visual, review-gated agent loops for Claude Code before you run them. - ksimback/looper",,2026-06-18,2026,ksimback/looper,GitHub,,,,github-api,ksimback/looper,685,62,2,"Design visual, review-gated agent loops for Claude Code before you run them.",MIT,2026-06-18T19:44:20Z,2026-07-18T07:51:27Z,,,2026-07-18T08:16:45+00:00
ale-0228,Agent Apprenticeship,https://github.com/Forsy-AI/agent-apprenticeship,external,github.com,ok,200,https://github.com/ray-r-ren/agent-apprenticeship,https://github.com/ray-r-ren/agent-apprenticeship,text/html; charset=utf-8,"GitHub - ray-r-ren/agent-apprenticeship: The living ecosystem where AI agents complete tasks through workflow loops, improve through iterative execution, are evaluated by mentor agents or humans in the loop, and turn completed work into reusable work experience and data to improve future agents. · GitHub","The living ecosystem where AI agents complete tasks through workflow loops, improve through iterative execution, are evaluated by mentor agents or humans in the loop, and turn completed work into reusable work experience and data to improve future agents. - ray-r-ren/agent-apprenticeship",,2026-06-19,2026,Forsy-AI/agent-apprenticeship,GitHub,,,,github-api,Forsy-AI/agent-apprenticeship,1317,56,0,"The living ecosystem where AI agents complete tasks through workflow loops, improve through iterative execution, are evaluated by mentor agents or humans in the loop, and turn completed work into reusable work experience and data to improve future agents.",MIT,2026-06-19T16:19:37Z,2026-07-18T07:39:42Z,,,2026-07-18T08:16:45+00:00
ale-0229,Scholar Loop,https://github.com/renee-jia/scholar-loop,external,github.com,ok,200,https://github.com/renee-jia/scholar-loop,https://github.com/renee-jia/scholar-loop,text/html; charset=utf-8,"GitHub - renee-jia/scholar-loop: An autonomous AI scientist: a multi-agent loop over literature, experiments, self-critique and write-up, with deterministic guards against reward-hacking and hallucination. · GitHub","An autonomous AI scientist: a multi-agent loop over literature, experiments, self-critique and write-up, with deterministic guards against reward-hacking and hallucination. - renee-jia/scholar-loop",,2026-06-15,2026,renee-jia/scholar-loop,GitHub,,,,github-api,renee-jia/scholar-loop,461,36,0,"An autonomous AI scientist: a multi-agent loop over literature, experiments, self-critique and write-up, with deterministic guards against reward-hacking and hallucination.",MIT,2026-06-15T04:50:58Z,2026-07-08T05:18:54Z,,,2026-07-18T08:16:45+00:00
ale-0230,loop-engineering (Cobus Greyling),https://github.com/cobusgreyling/loop-engineering,external,github.com,ok,200,https://github.com/cobusgreyling/loop-engineering,https://github.com/cobusgreyling/loop-engineering,text/html; charset=utf-8,"GitHub - cobusgreyling/loop-engineering: Practical patterns, starters & CLI tools for loop engineering with AI coding agents. Design systems that prompt and orchestrate agents (inspired by Addy Osmani and Boris Cherny). Includes loop-audit, loop-init, loop-cost. · GitHub","Practical patterns, starters & CLI tools for loop engineering with AI coding agents. Design systems that prompt and orchestrate agents (inspired by Addy Osmani and Boris Cherny). Includes loop-audit, loop-init, loop-cost. - cobusgreyling/loop-engineering",,2026-06-09,2026,cobusgreyling/loop-engineering,GitHub,,,,github-api,cobusgreyling/loop-engineering,8353,1107,24,"Practical patterns, starters & CLI tools for loop engineering with AI coding agents. Design systems that prompt and orchestrate agents (inspired by Addy Osmani and Boris Cherny). Includes loop-audit, loop-init, loop-cost.",MIT,2026-06-09T06:28:20Z,2026-07-18T07:52:57Z,,,2026-07-18T08:16:45+00:00
ale-0231,AutoCVE,https://github.com/larlarua/AutoCVE,external,github.com,ok,200,https://github.com/larlarua/AutoCVE,https://github.com/larlarua/AutoCVE,text/html; charset=utf-8,"GitHub - larlarua/AutoCVE: Agent-driven automated CVE discovery platform for source code auditing, vulnerability verification, and report generation. · GitHub","Agent-driven automated CVE discovery platform for source code auditing, vulnerability verification, and report generation. - larlarua/AutoCVE",,2026-06-15,2026,larlarua/AutoCVE,GitHub,,,,github-api,larlarua/AutoCVE,1302,89,14,"Agent-driven automated CVE discovery platform for source code auditing, vulnerability verification, and report generation.",AGPL-3.0,2026-06-15T14:50:47Z,2026-07-18T07:19:19Z,,,2026-07-18T08:16:45+00:00
ale-0232,LoongFlow (Baidu),https://github.com/baidu-baige/LoongFlow,external,github.com,ok,200,https://github.com/baidu-baige/LoongFlow,https://github.com/baidu-baige/LoongFlow,text/html; charset=utf-8,"GitHub - baidu-baige/LoongFlow: LoongFlow is an expert-grade Agent framework for Loop Engineering. Through a Plan-Execute-Summary loop and structured experiential memory, it enables AI to continuously think, execute, reflect, and evolve across complex software engineering, mathematical, and machine learning tasks. · GitHub","LoongFlow is an expert-grade Agent framework for Loop Engineering. Through a Plan-Execute-Summary loop and structured experiential memory, it enables AI to continuously think, execute, reflect, and evolve across complex software engineering, mathematical, and machine learning tasks. - baidu-baige/LoongFlow",,2025-12-31,2025,baidu-baige/LoongFlow,GitHub,,,,github-api,baidu-baige/LoongFlow,452,52,0,"LoongFlow is an expert-grade Agent framework for Loop Engineering. Through a Plan-Execute-Summary loop and structured experiential memory, it enables AI to continuously think, execute, reflect, and evolve across complex software engineering, mathematical, and machine learning tasks.",Apache-2.0,2025-12-31T05:36:46Z,2026-07-17T02:37:11Z,,,2026-07-18T08:16:45+00:00
ale-0233,cc10x,https://github.com/romiluz13/cc10x,external,github.com,ok,200,https://github.com/romiluz13/cc10x,https://github.com/romiluz13/cc10x,text/html; charset=utf-8,"GitHub - romiluz13/cc10x: The Loop Engine for Claude Code — engineer the loop, not the prompt. 1 router · 9 agents · 16 skills · 4 workflows. Fail-closed gates, test honesty, anti-anchored review. · GitHub","The Loop Engine for Claude Code — engineer the loop, not the prompt. 1 router · 9 agents · 16 skills · 4 workflows. Fail-closed gates, test honesty, anti-anchored review. - romiluz13/cc10x",,2025-10-22,2025,romiluz13/cc10x,GitHub,,,,github-api,romiluz13/cc10x,153,25,2,"The Loop Engine for Claude Code — engineer the loop, not the prompt. 1 router · 9 agents · 16 skills · 4 workflows. Fail-closed gates, test honesty, anti-anchored review.",MIT,2025-10-22T11:54:14Z,2026-07-16T06:46:07Z,,,2026-07-18T08:16:45+00:00
ale-0234,RigorLoop,https://github.com/ronikobrosly/RigorLoop,external,github.com,ok,200,https://github.com/ronikobrosly/RigorLoop,https://github.com/ronikobrosly/RigorLoop,text/html; charset=utf-8,"GitHub - ronikobrosly/RigorLoop: A statistically-sound agentic build framework that employs agentic loops to create code artifacts (whether a script, a skill markdown file, etc). Crucially, it splits verification data into the classic data science-like dev, validation, and final test sets to avoid overfitting. · GitHub","A statistically-sound agentic build framework that employs agentic loops to create code artifacts (whether a script, a skill markdown file, etc). Crucially, it splits verification data into the classic data science-like dev, validation, and final test sets to avoid overfitting. - GitHub - ronikobrosly/RigorLoop: A statistically-sound agentic build framework that employs agentic loops to create code artifacts (whether a script, a skill markdown file, etc). Crucially, it splits verification data into the classic data science-like dev, validation, and final test sets to avoid overfitting.",,2026-07-08,2026,ronikobrosly/RigorLoop,GitHub,,,,github-api,ronikobrosly/RigorLoop,134,1,2,"A statistically-sound agentic build framework that employs agentic loops to create code artifacts (whether a script, a skill markdown file, etc). Crucially, it splits verification data into the classic data science-like dev, validation, and final test sets to avoid overfitting.",MIT,2026-07-08T14:38:05Z,2026-07-17T00:53:18Z,,,2026-07-18T08:16:45+00:00
ale-0235,Open-Inspect,https://github.com/ColeMurray/background-agents,external,github.com,ok,200,https://github.com/ColeMurray/background-agents,https://github.com/ColeMurray/background-agents,text/html; charset=utf-8,GitHub - ColeMurray/background-agents: An open-source background agents coding system · GitHub,An open-source background agents coding system. Contribute to ColeMurray/background-agents development by creating an account on GitHub.,,2026-01-25,2026,ColeMurray/background-agents,GitHub,,,,github-api,ColeMurray/background-agents,2495,356,54,An open-source background agents coding system,MIT,2026-01-25T18:45:47Z,2026-07-18T06:55:00Z,,,2026-07-18T08:16:45+00:00
ale-0236,T3MP3ST,https://github.com/elder-plinius/T3MP3ST,external,github.com,ok,200,https://github.com/elder-plinius/T3MP3ST,https://github.com/elder-plinius/T3MP3ST,text/html; charset=utf-8,GitHub - elder-plinius/T3MP3ST: autonomous red teaming platform; multi-agent offensive-security meta-harness · GitHub,autonomous red teaming platform; multi-agent offensive-security meta-harness - elder-plinius/T3MP3ST,,2026-07-02,2026,elder-plinius/T3MP3ST,GitHub,,,,github-api,elder-plinius/T3MP3ST,4912,1027,11,autonomous red teaming platform; multi-agent offensive-security meta-harness,AGPL-3.0,2026-07-02T17:53:55Z,2026-07-18T08:14:17Z,,,2026-07-18T08:16:45+00:00
ale-0237,Loom,https://github.com/valkor-ai/loom,external,github.com,ok,200,https://github.com/valkor-ai/loom,https://github.com/valkor-ai/loom,text/html; charset=utf-8,GitHub - valkor-ai/loom: Loop engineering for agentic software delivery. · GitHub,Loop engineering for agentic software delivery. Contribute to valkor-ai/loom development by creating an account on GitHub.,,2026-06-09,2026,valkor-ai/loom,GitHub,,,,github-api,valkor-ai/loom,587,63,7,Loop engineering for agentic software delivery.,Apache-2.0,2026-06-09T03:46:34Z,2026-07-17T19:00:23Z,,,2026-07-18T08:16:45+00:00
ale-0238,Inferoa,https://github.com/agentic-in/inferoa,external,github.com,ok,200,https://github.com/agentic-in/inferoa,https://github.com/agentic-in/inferoa,text/html; charset=utf-8,GitHub - agentic-in/inferoa: Inference-native Tokenmaxxing Agent Harness for Loop Engineering · GitHub,Inference-native Tokenmaxxing Agent Harness for Loop Engineering - agentic-in/inferoa,,2026-06-08,2026,agentic-in/inferoa,GitHub,,,,github-api,agentic-in/inferoa,486,84,48,Inference-native Tokenmaxxing Agent Harness for Loop Engineering,Apache-2.0,2026-06-08T06:29:56Z,2026-07-16T10:37:09Z,,,2026-07-18T08:16:45+00:00
ale-0239,PlanWeave,https://github.com/GaosCode/PlanWeave,external,github.com,ok,200,https://github.com/GaosCode/PlanWeave,https://github.com/GaosCode/PlanWeave,text/html; charset=utf-8,"GitHub - GaosCode/PlanWeave: PlanWeave is a file-backed loop engineering system for long-running coding agents. It turns fuzzy plans into claimable tasks, routes them through implementation and review agents, records every run, and keeps the loop recoverable. · GitHub","PlanWeave is a file-backed loop engineering system for long-running coding agents. It turns fuzzy plans into claimable tasks, routes them through implementation and review agents, records every run, and keeps the loop recoverable. - GaosCode/PlanWeave",,2026-05-24,2026,GaosCode/PlanWeave,GitHub,,,,github-api,GaosCode/PlanWeave,226,15,1,"PlanWeave is a file-backed loop engineering system for long-running coding agents. It turns fuzzy plans into claimable tasks, routes them through implementation and review agents, records every run, and keeps the loop recoverable.",MIT,2026-05-24T06:01:56Z,2026-07-18T07:20:49Z,,,2026-07-18T08:16:45+00:00
ale-0240,loop.js,https://github.com/loop-js/loop.js,external,github.com,ok,200,https://github.com/loop-js/loop.js,https://github.com/loop-js/loop.js,text/html; charset=utf-8,"GitHub - loop-js/loop.js: A loop engineering framework — state a Goal; Rounds run until a skeptical, read-only Verify agent settles it. · GitHub","A loop engineering framework — state a Goal; Rounds run until a skeptical, read-only Verify agent settles it. - loop-js/loop.js",,2026-07-10,2026,loop-js/loop.js,GitHub,,,,github-api,loop-js/loop.js,126,1,20,"A loop engineering framework — state a Goal; Rounds run until a skeptical, read-only Verify agent settles it.",Apache-2.0,2026-07-10T10:59:54Z,2026-07-17T16:58:07Z,,,2026-07-18T08:16:45+00:00
ale-0241,ai-trains-ai,https://github.com/Danau5tin/ai-trains-ai,external,github.com,ok,200,https://github.com/Danau5tin/ai-trains-ai,https://github.com/Danau5tin/ai-trains-ai,text/html; charset=utf-8,GitHub - Danau5tin/ai-trains-ai: RL-training an AI agent to RL-train AI agents. · GitHub,RL-training an AI agent to RL-train AI agents. Contribute to Danau5tin/ai-trains-ai development by creating an account on GitHub.,,2026-07-07,2026,Danau5tin/ai-trains-ai,GitHub,,,,github-api,Danau5tin/ai-trains-ai,189,14,0,RL-training an AI agent to RL-train AI agents.,MIT,2026-07-07T07:45:52Z,2026-07-18T04:27:46Z,,,2026-07-18T08:16:45+00:00
ale-0242,Factory 2.0: From Coding Agents to Software Factories,https://factory.ai/news/software-factory,external,factory.ai,ok,200,https://factory.ai/news/software-factory,https://factory.ai/news/software-factory,text/html; charset=utf-8,Factory 2.0: From coding agents to software factories | Factory.ai Factory.ai Logo Arrow Right Icon,"In 2023, we launched Factory with the mission to bring autonomy to software engineering. While others were using models...",Factory,2026-06-15,2026,,Factory,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0243,Superpowers 6,https://blog.fsck.com/2026/06/15/Superpowers-6/,external,blog.fsck.com,ok,200,https://blog.fsck.com/2026/06/15/Superpowers-6/,https://blog.fsck.com/2026/06/15/Superpowers-6/,text/html; charset=utf-8,Superpowers 6 — Massively Parallel Procrastination,"I'm Jesse. I make stuff. Software, hardware. Very occasionally, trouble.",,,2026,,Massively Parallel Procrastination,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0244,Introducing Devin Security Swarm,https://cognition.com/blog/introducing-devin-security-swarm,external,cognition.com,ok,200,https://cognition.com/blog/introducing-devin-security-swarm,https://cognition.com/blog/introducing-devin-security-swarm,text/html; charset=utf-8,Introducing Devin Security Swarm | Cognition,"Devin Security Swarm finds vulnerabilities across the codebase, validates exploitability at runtime, and ships remediation PRs.",,2026-07-01,2026,,cognition.com,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0245,Towards Self-Driving Codebases,https://cursor.com/blog/self-driving-codebases,external,cursor.com,ok,200,https://cursor.com/blog/self-driving-codebases,https://cursor.com/blog/self-driving-codebases,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0246,Factory: Incident Response Automation,https://factory.ai/news/incident-response,external,factory.ai,ok,200,https://factory.ai/news/incident-response,https://factory.ai/news/incident-response,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0247,A Week-Long Autonomous Voxel Manhattan Build,https://x.com/mattshumer_/status/2075268746315268138,external,x.com,ok,200,https://x.com/mattshumer_/status/2075268746315268138,https://x.com/mattshumer_/status/2075268746315268138,text/html; charset=UTF-8,"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-18T08:16:45+00:00
ale-0248,Self-Improving AI Coding Agents Through Accumulated Behavioral Rules: A Closed-Loop Framework,https://arxiv.org/abs/2607.13091,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.13091,https://arxiv.org/abs/2607.13091,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0249,Webwright,https://github.com/microsoft/Webwright,external,github.com,ok,200,https://github.com/microsoft/Webwright,https://github.com/microsoft/Webwright,text/html; charset=utf-8,GitHub - microsoft/Webwright: A simple SWE style browser agent framework that achieves SOTA results on long horizon web tasks. · GitHub,A simple SWE style browser agent framework that achieves SOTA results on long horizon web tasks. - GitHub - microsoft/Webwright: A simple SWE style browser agent framework that achieves SOTA results on long horizon web tasks.,,2026-04-08,2026,microsoft/Webwright,GitHub,,,,github-api,microsoft/Webwright,5818,366,45,A simple SWE style browser agent framework that achieves SOTA results on long horizon web tasks.,MIT,2026-04-08T01:48:09Z,2026-07-17T08:21:38Z,,,2026-07-18T08:16:45+00:00
ale-0250,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,ok,200,https://streamzero.com/blog/posts/deep-dives-tools-technologies-architectures/agentic-patterns/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,text/html; charset=UTF-8,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-18T08:16:45+00:00
ale-0251,Stop Babysitting Your Coding Agent. Give It Backpressure.,https://generativeprogrammer.com/p/stop-babysitting-your-coding-agent,external,generativeprogrammer.com,ok,200,https://generativeprogrammer.com/p/stop-babysitting-your-coding-agent,https://generativeprogrammer.com/p/stop-babysitting-your-coding-agent,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0252,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,ok,200,https://dev.to/shipwithaiio/how-to-build-a-self-verification-loop-in-claude-code-3-layers-20-minutes-m1p,https://dev.to/shipwithaiio/how-to-build-a-self-verification-loop-in-claude-code-3-layers-20-minutes-m1p,text/html; charset=utf-8,"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-18T08:16:45+00:00
ale-0253,Agentic Code Review,https://addyosmani.com/blog/agentic-code-review/,external,addyosmani.com,ok,200,https://addyosmani.com/blog/agentic-code-review/,https://addyosmani.com/blog/agentic-code-review/,text/html; charset=UTF-8,AddyOsmani.com - Agentic Code Review,"Coding agents are extraordinarily good now, and getting better fast. The interesting consequence is that the hard part of engineering moved from writing code...",Addy Osmani,,,,addyosmani.com,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0254,Using DSPy to Evaluate and Improve Datasette Agent's SQL System Prompts,https://simonwillison.net/2026/Jul/2/dspy-datasette-agent-prompts/,external,simonwillison.net,ok,200,https://simonwillison.net/2026/Jul/2/dspy-datasette-agent-prompts/,https://simonwillison.net/2026/Jul/2/dspy-datasette-agent-prompts/,text/html; charset=utf-8,Research: Using DSPy to evaluate and improve Datasette Agent's SQL system prompts,"Leveraging the DSPy framework, this project evaluates and refines the core production system prompts used by Datasette Agent’s read-only SQL question answerer. The methodology involves a harness where DSPy agents …",Simon Willison,,2026,,Simon Willison’s Weblog,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0255,Agentic coding notes,https://danluu.com/ai-coding/,external,danluu.com,ok,200,https://danluu.com/ai-coding/,https://danluu.com/ai-coding/,text/html; charset=utf-8,"Agentic test processes, LLM benchmarks, and other notes on agentic coding from Galapagos Island",,,,,,danluu.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0256,Understanding Is the New Bottleneck,https://www.geoffreylitt.com/2026/07/02/understanding-is-the-new-bottleneck.html,external,www.geoffreylitt.com,ok,200,https://www.geoffreylitt.com/2026/07/02/understanding-is-the-new-bottleneck.html,https://www.geoffreylitt.com/2026/07/02/understanding-is-the-new-bottleneck.html,text/html; charset=UTF-8,Understanding is the new bottleneck,"Agents can write code faster than we can absorb it. Here's why it still matters for humans to understand what they build — and some techniques for doing that efficiently: explainer docs, quizzes, micro-worlds, and shared spaces.",,,2026,,geoffreylitt.com,,,,url-date,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0257,Verifying Agentic Development at Scale,https://cognition.com/blog/testing-development,external,cognition.com,ok,200,https://cognition.com/blog/testing-development,https://cognition.com/blog/testing-development,text/html; charset=utf-8,Verifying Agentic Development at Scale | Cognition,What we’ve learned building end-to-end testing capabilities in Devin’s virtual machine,,2026-05-29,2026,,cognition.com,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0258,Loop Engineering Without Verification Is Just Automation,https://www.sonarsource.com/blog/loop-engineering-without-verification-is-just-automation/,external,www.sonarsource.com,ok,200,https://www.sonarsource.com/blog/loop-engineering-without-verification-is-just-automation/,https://www.sonarsource.com/blog/loop-engineering-without-verification-is-just-automation/,text/html,Loop engineering without verification is just automation | Sonar,Explore how LLM reviewers and deterministic checks work together to keep coding agent loops from shipping unfinished code.,,,,,sonarsource.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0259,Closing the Verification Loop: Observability-Driven Harnesses,https://www.datadoghq.com/blog/ai/harness-first-agents/,external,www.datadoghq.com,ok,200,https://www.datadoghq.com/blog/ai/harness-first-agents/,https://www.datadoghq.com/blog/ai/harness-first-agents/,text/html,Closing the verification loop: Observability-driven harnesses for building with agents | Datadog security-platform rum ci dashboard host-map apm security-platform rum ci dashboard host-map apm security-platform rum ci dashboard Icon/world,"Learn how Datadog verifies AI-generated systems at scale using deterministic testing, formal methods, and observability-driven feedback loops.","Alp Keles, Jai Menon, Sesh Nalla, Vyom Shah",2026-03-09,2026,,Datadog,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0260,How to build a better agent harness with traces and evals,https://arize.com/blog/improve-ai-agents-traces-evals-harness/,external,arize.com,ok,200,https://arize.com/blog/improve-ai-agents-traces-evals-harness/,https://arize.com/blog/improve-ai-agents-traces-evals-harness/,text/html; charset=UTF-8,How to build a better agent harness with traces and evals - Arize AI,"Agents are easy to prototype and hard to improve. A repeatable loop of traces, evals, failed-span inspection, and targeted harness changes makes agent behavior easier to debug and improve.",Aaron Winston,2026-05-29,2026,,Arize AI,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0261,Better Harness: A Recipe for Harness Hill-Climbing with Evals,https://www.langchain.com/blog/better-harness-a-recipe-for-harness-hill-climbing-with-evals,external,www.langchain.com,ok,200,https://www.langchain.com/blog/better-harness-a-recipe-for-harness-hill-climbing-with-evals,https://www.langchain.com/blog/better-harness-a-recipe-for-harness-hill-climbing-with-evals,text/html; charset=utf-8,Better Harness: A Recipe for Harness Hill-Climbing with Evals,"We can build better agents by building better harnesses. But to autonomously build a “better” harness, we need a strong learning signal to “hill-climb” on. We share how we use evals as that signal, plus design decisions that help our agent generalize instead of overfit. Better-Harness is a system for iteratively sourcing and improving your harness with evals.",,,,,LangChain,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0262,Improving Deep Agents with harness engineering,https://www.langchain.com/blog/improving-deep-agents-with-harness-engineering,external,www.langchain.com,ok,200,https://www.langchain.com/blog/improving-deep-agents-with-harness-engineering,https://www.langchain.com/blog/improving-deep-agents-with-harness-engineering,text/html; charset=utf-8,Improving Deep Agents with harness engineering,"Harness engineering improved LangChain's coding agent from Top 30 to Top 5 on Terminal Bench using self-verification, tracing, and context optimization.",,,,,LangChain,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0263,Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses,https://arxiv.org/abs/2604.25850,external,arxiv.org,ok,200,https://arxiv.org/abs/2604.25850,https://arxiv.org/abs/2604.25850,text/html; charset=utf-8,[2604.25850] Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses,"Harnesses are now central to coding-agent performance, mediating how models interact with tools and execution environments. Yet harness engineering remains a manual craft, because automating it faces a heterogeneous action space across editable components, voluminous trajectories that bury actionable signal, and edits whose effect is hard to attribute. We introduce Agentic Harness Engineering (AHE), a closed loop that addresses these challenges through three matched observability pillars: (1) component observability gives every editable harness component a file-level representation so the action space is explicit and revertible; (2) experience observability distills millions of raw trajectory tokens into a layered, drill-down evidence corpus that an evolving agent can actually consume; and (3) decision observability pairs every edit with a self-declared prediction, later verified against the next round's task-level outcomes. Together, these pillars turn every edit into a falsifiable contract, so harness evolution proceeds autonomously without collapsing into trial-and-error. Empirically, ten AHE iterations lift pass@1 on Terminal-Bench 2 from 69.7% to 77.0%, surpassing the human-designed harness Codex-CLI (71.9%) and the self-evolving baselines ACE and TF-GRPO. The frozen harness transfers without re-evolution: on SWE-bench-verified it tops aggregate success at 12% fewer tokens than the seed, and on Terminal-Bench 2 it yields +5.1 to +10.1pp cross-family gains across three alternate model families, indicating the evolved components encode general engineering experience rather than benchmark-specific tuning. Ablations localize the gain to tools, middleware, and long-term memory rather than the system prompt, suggesting factual harness structure transfers while prose-level strategy does not.",Jiahang Lin; Shichun Liu; Chengjun Pan; Lizhi Lin; Shihan Dou; Zhiheng Xi; Xuanjing Huang; Hang Yan; Zhenhua Han; Tao Gui; Yu-Gang Jiang,2026-04-28,2026,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,,,2604.25850,,2026-07-18T08:16:45+00:00
ale-0264,Meta-Harness: End-to-End Optimization of Model Harnesses,https://arxiv.org/abs/2603.28052,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.28052,https://arxiv.org/abs/2603.28052,text/html; charset=utf-8,[2603.28052] Meta-Harness: End-to-End Optimization of Model Harnesses,"The performance of large language model (LLM) systems depends not only on model weights, but also on their harness: the code that determines what information to store, retrieve, and present to the model. Yet harnesses are still designed largely by hand, and existing text optimizers are poorly matched to this setting because they compress feedback too aggressively. We introduce Meta-Harness, an outer-loop system that searches over harness code for LLM applications. It uses an agentic proposer that accesses the source code, scores, and execution traces of all prior candidates through a filesystem. On online text classification, Meta-Harness improves over a state-of-the-art context management system by 7.7 points while using 4x fewer context tokens. On retrieval-augmented math reasoning, a single discovered harness improves accuracy on 200 IMO-level problems by 4.7 points on average across five held-out models. On agentic coding, discovered harnesses surpass the best hand-engineered baselines on TerminalBench-2. Together, these results show that richer access to prior experience can enable automated harness engineering.",Yoonho Lee; Roshen Nair; Qizheng Zhang; Kangwook Lee; Omar Khattab; Chelsea Finn,2026-03-30,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2603.28052,,2026-07-18T08:16:45+00:00
ale-0265,HALO (Hierarchical Agent Loop Optimizer),https://github.com/context-labs/halo,external,github.com,ok,200,https://github.com/context-labs/halo,https://github.com/context-labs/halo,text/html; charset=utf-8,GitHub - context-labs/HALO: Hierarchal Agent Loop Optimizer · GitHub,Hierarchal Agent Loop Optimizer. Contribute to context-labs/HALO development by creating an account on GitHub.,,2026-04-21,2026,context-labs/halo,GitHub,,,,github-api,context-labs/halo,1107,80,8,Hierarchal Agent Loop Optimizer,,2026-04-21T18:20:46Z,2026-07-18T05:49:41Z,,,2026-07-18T08:16:45+00:00
ale-0266,"Harness-Aware Self-Evolving: Co-Evolving Model Weights, Harness, and Task Solutions",https://arxiv.org/abs/2607.03935,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.03935,https://arxiv.org/abs/2607.03935,text/html; charset=utf-8,"[2607.03935] Harness-Aware Self-Evolving: Co-Evolving Model Weights, Harness, and Task Solutions","Self-evolving frameworks usually optimize task solutions while treating the surrounding harness as fixed. We introduce Harness-Aware Self-Evolving (HASE), an agentic reinforcement-learning framework in which a single model can generate task solutions or edit selected harness components in a multi-turn action space. HASE enables a single Qwen3-8B model to match the text-classification performance of a GPT-OSS-120B model that uses Claude Code as the harness proposer. In alpha factor mining, HASE outperforms the reported GPT-OSS-120B baseline. HASE also repairs imperfect evaluation components and converges to state-of-the-art performance in circle-packing algorithm discovery. These results show that HASE improves the harness and the solution through one unified agentic process.",Haochen Luo; Yi Huang; Sichun Luo; Fengyuan Liu; Lei Li; Zefa Hu; Junlan Feng; Qi Liu,2026-07-04,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.03935,,2026-07-18T08:16:45+00:00
ale-0267,auto-harness,https://github.com/neosigmaai/auto-harness,external,github.com,ok,200,https://github.com/neosigmaai/auto-harness,https://github.com/neosigmaai/auto-harness,text/html; charset=utf-8,"GitHub - neosigmaai/auto-harness: Bring your own agent and build a self-improving agentic system. Automatically mine failures, optimize the agent harness, and gate against regressions. · GitHub","Bring your own agent and build a self-improving agentic system. Automatically mine failures, optimize the agent harness, and gate against regressions. - neosigmaai/auto-harness",,2026-04-03,2026,neosigmaai/auto-harness,GitHub,,,,github-api,neosigmaai/auto-harness,525,59,10,"Bring your own agent and build a self-improving agentic system. Automatically mine failures, optimize the agent harness, and gate against regressions.",MIT,2026-04-03T21:18:14Z,2026-07-16T14:02:38Z,,,2026-07-18T08:16:45+00:00
ale-0268,OpenAI agent evals,https://developers.openai.com/api/docs/guides/agent-evals,external,developers.openai.com,ok,200,https://developers.openai.com/api/docs/guides/agent-evals,https://developers.openai.com/api/docs/guides/agent-evals,text/html; charset=utf-8,Evaluate agent workflows | OpenAI API,"Learn how to evaluate agent workflows with traces, graders, datasets, and evaluation runs on the OpenAI platform.",,,,,OpenAI Developers,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0269,Promptfoo OpenAI Agents provider,https://www.promptfoo.dev/docs/providers/openai-agents/,external,www.promptfoo.dev,ok,200,https://www.promptfoo.dev/docs/providers/openai-agents/,https://www.promptfoo.dev/docs/providers/openai-agents/,text/html; charset=utf-8,OpenAI Agents | Promptfoo,"Test OpenAI Agents with tools, handoffs, sessions, sandbox workflows, and tracing in promptfoo.",,,,,promptfoo.dev,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0270,Inspect AI,https://github.com/UKGovernmentBEIS/inspect_ai,external,github.com,ok,200,https://github.com/UKGovernmentBEIS/inspect_ai,https://github.com/UKGovernmentBEIS/inspect_ai,text/html; charset=utf-8,GitHub - UKGovernmentBEIS/inspect_ai: Inspect: A framework for large language model evaluations · GitHub,Inspect: A framework for large language model evaluations - UKGovernmentBEIS/inspect_ai,,2023-11-14,2023,UKGovernmentBEIS/inspect_ai,GitHub,,,,github-api,UKGovernmentBEIS/inspect_ai,2371,609,238,Inspect: A framework for large language model evaluations,MIT,2023-11-14T14:53:11Z,2026-07-18T06:50:31Z,,,2026-07-18T08:16:45+00:00
ale-0271,OpenTelemetry Semantic Conventions for Generative AI Systems,https://opentelemetry.io/docs/specs/semconv/gen-ai/,external,opentelemetry.io,ok,200,https://opentelemetry.io/docs/specs/semconv/gen-ai/,https://opentelemetry.io/docs/specs/semconv/gen-ai/,text/html; charset=UTF-8,Moved: Generative AI semantic conventions | OpenTelemetry The OpenTelemetry Logo,Important GenAI semantic conventions have moved to the OpenTelemetry GenAI semantic conventions repository. This page has moved and is no longer maintained in this repository.,,,,,OpenTelemetry,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0272,AgentOps,https://github.com/AgentOps-AI/agentops,external,github.com,ok,200,https://github.com/AgentOps-AI/agentops,https://github.com/AgentOps-AI/agentops,text/html; charset=utf-8,"GitHub - AgentOps-AI/agentops: Python SDK for AI agent monitoring, LLM cost tracking, benchmarking, and more. Integrates with most LLMs and agent frameworks including CrewAI, Agno, OpenAI Agents SDK, Langchain, Autogen, AG2, and CamelAI · GitHub","Python SDK for AI agent monitoring, LLM cost tracking, benchmarking, and more. Integrates with most LLMs and agent frameworks including CrewAI, Agno, OpenAI Agents SDK, Langchain, Autogen, AG2, and CamelAI - AgentOps-AI/agentops",,2023-08-15,2023,AgentOps-AI/agentops,GitHub,,,,github-api,AgentOps-AI/agentops,5716,609,173,"Python SDK for AI agent monitoring, LLM cost tracking, benchmarking, and more. Integrates with most LLMs and agent frameworks including CrewAI, Agno, OpenAI Agents SDK, Langchain, Autogen, AG2, and CamelAI",MIT,2023-08-15T23:26:23Z,2026-07-18T02:20:10Z,,,2026-07-18T08:16:45+00:00
ale-0273,Langfuse,https://github.com/langfuse/langfuse,external,github.com,ok,200,https://github.com/langfuse/langfuse,https://github.com/langfuse/langfuse,text/html; charset=utf-8,"GitHub - langfuse/langfuse: 🪢 Open source AI engineering platform: LLM evals, observability, metrics, prompt management, playground, datasets. Integrates with OpenTelemetry, LangChain, OpenAI SDK, LiteLLM, and more. 🍊YC W23 · GitHub","🪢 Open source AI engineering platform: LLM evals, observability, metrics, prompt management, playground, datasets. Integrates with OpenTelemetry, LangChain, OpenAI SDK, LiteLLM, and more. 🍊YC W23 - GitHub - langfuse/langfuse: 🪢 Open source AI engineering platform: LLM evals, observability, metrics, prompt management, playground, datasets. Integrates with OpenTelemetry, LangChain, OpenAI SDK, LiteLLM, and more. 🍊YC W23",,2023-05-18,2023,langfuse/langfuse,GitHub,,,,github-api,langfuse/langfuse,31361,3310,705,"🪢 Open source AI engineering platform: LLM evals, observability, metrics, prompt management, playground, datasets. Integrates with OpenTelemetry, LangChain, OpenAI SDK, LiteLLM, and more. 🍊YC W23",NOASSERTION,2023-05-18T17:47:09Z,2026-07-18T08:09:56Z,,,2026-07-18T08:16:45+00:00
ale-0274,LangSmith,https://www.langchain.com/langsmith,external,www.langchain.com,ok,200,https://www.langchain.com/langsmith/observability,https://www.langchain.com/langsmith/observability,text/html; charset=utf-8,LangSmith: Agent & LLM Observability Platform,"Complete AI agent and LLM observability platform with tracing and real-time monitoring. Debug agents, find failures fast, and track costs and latency.",,,,,LangChain,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0275,Arize Phoenix,https://github.com/Arize-ai/phoenix,external,github.com,ok,200,https://github.com/Arize-ai/phoenix,https://github.com/Arize-ai/phoenix,text/html; charset=utf-8,GitHub - Arize-ai/phoenix: AI Observability & Evaluation · GitHub,AI Observability & Evaluation. Contribute to Arize-ai/phoenix development by creating an account on GitHub.,,2022-11-09,2022,Arize-ai/phoenix,GitHub,,,,github-api,Arize-ai/phoenix,10609,993,757,AI Observability & Evaluation,NOASSERTION,2022-11-09T23:44:35Z,2026-07-18T08:13:38Z,,,2026-07-18T08:16:45+00:00
ale-0276,Braintrust,https://www.braintrust.dev/,external,www.braintrust.dev,ok,200,https://www.braintrust.dev/,https://www.braintrust.dev/,text/html; charset=utf-8,Braintrust - The AI observability platform for building quality AI products,"Ship quality AI at scale. Braintrust is the AI observability platform for tracing production, running evals, and catching regressions before they reach users.",,,,,Braintrust,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0277,Weave,https://docs.wandb.ai/weave,external,docs.wandb.ai,ok,200,https://docs.wandb.ai/weave,https://docs.wandb.ai/weave,text/html; charset=utf-8,W&B Weave - Weights & Biases Documentation,"Track, test, and improve language model apps with W&B Weave",,,,,Weights & Biases Documentation,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0278,agentops (boshu2),https://github.com/boshu2/agentops,external,github.com,ok,200,https://github.com/boshu2/agentops,https://github.com/boshu2/agentops,text/html; charset=utf-8,GitHub - boshu2/agentops: The operating loop a coding agent follows — and skills to orchestrate multi-agent systems. · GitHub,The operating loop a coding agent follows — and skills to orchestrate multi-agent systems. - boshu2/agentops,,2025-11-05,2025,boshu2/agentops,GitHub,,,,github-api,boshu2/agentops,412,40,0,The operating loop a coding agent follows — and skills to orchestrate multi-agent systems.,Apache-2.0,2025-11-05T19:18:56Z,2026-07-17T20:54:17Z,,,2026-07-18T08:16:45+00:00
ale-0279,SkillSpec,https://github.com/modiqo/skillspec,external,github.com,ok,200,https://github.com/modiqo/skillspec,https://github.com/modiqo/skillspec,text/html; charset=utf-8,"GitHub - modiqo/skillspec: SkillSpec makes agent skills followable, testable, and provable with Doctor risk reports, guided imports, structured contracts, and alignment proof. · GitHub","SkillSpec makes agent skills followable, testable, and provable with Doctor risk reports, guided imports, structured contracts, and alignment proof. - modiqo/skillspec",,2026-06-19,2026,modiqo/skillspec,GitHub,,,,github-api,modiqo/skillspec,984,60,8,"SkillSpec makes agent skills followable, testable, and provable with Doctor risk reports, guided imports, structured contracts, and alignment proof.",Apache-2.0,2026-06-19T23:42:55Z,2026-07-18T08:17:13Z,,,2026-07-18T08:16:45+00:00
ale-0280,Shepherd,https://github.com/shepherd-agents/shepherd,external,github.com,ok,200,https://github.com/shepherd-agents/shepherd,https://github.com/shepherd-agents/shepherd,text/html; charset=utf-8,"GitHub - shepherd-agents/shepherd: A runtime substrate that turns an agent's execution into a reversible, Git-like trace, so meta-agents can observe, fork, replay, and revert any run. Couples agent and environments in a copy-on-write fork ~5x faster than docker commit, with ~95% KV-cache reuse on replay. Framework built for meta-agents to supervise, optimize, and train other agents · GitHub","A runtime substrate that turns an agent's execution into a reversible, Git-like trace, so meta-agents can observe, fork, replay, and revert any run. Couples agent and environments in a copy-on-write fork ~5x faster than docker commit, with ~95% KV-cache reuse on replay. Framework built for meta-agents to supervise, optimize, and train other agents - shepherd-agents/shepherd",,2026-06-24,2026,shepherd-agents/shepherd,GitHub,,,,github-api,shepherd-agents/shepherd,1458,105,7,"A runtime substrate that turns an agent's execution into a reversible, Git-like trace, so meta-agents can observe, fork, replay, and revert any run. Couples agent and environments in a copy-on-write fork ~5x faster than docker commit, with ~95% KV-cache reuse on replay. Framework built for meta-agents to supervise, optimize, and train other agents",MIT,2026-06-24T17:26:46Z,2026-07-18T03:52:49Z,,,2026-07-18T08:16:45+00:00
ale-0281,grill-for-unknowns,https://github.com/nicobailon/grill-for-unknowns,external,github.com,ok,200,https://github.com/nicobailon/grill-for-unknowns,https://github.com/nicobailon/grill-for-unknowns,text/html; charset=utf-8,"GitHub - nicobailon/grill-for-unknowns: Agent skill for finding unknowns, grilling plans, and reaching shared understanding before implementation · GitHub","Agent skill for finding unknowns, grilling plans, and reaching shared understanding before implementation - nicobailon/grill-for-unknowns",,2026-07-09,2026,nicobailon/grill-for-unknowns,GitHub,,,,github-api,nicobailon/grill-for-unknowns,179,6,0,"Agent skill for finding unknowns, grilling plans, and reaching shared understanding before implementation",MIT,2026-07-09T18:55:30Z,2026-07-18T05:29:34Z,,,2026-07-18T08:16:45+00:00
ale-0282,Fable Harness,https://github.com/Miguok/fable-harness,external,github.com,ok,200,https://github.com/Miguok/fable-harness,https://github.com/Miguok/fable-harness,text/html; charset=utf-8,"GitHub - Miguok/fable-harness: Make Claude Code work like a disciplined engineer: OODA, multi-party adversarial review, tiered model routing, fail-then-pass — token-efficient by design (route heavy work to smaller models, isolate sub-agent context). Distilled from Fable to reinforce the Opus harness. · GitHub","Make Claude Code work like a disciplined engineer: OODA, multi-party adversarial review, tiered model routing, fail-then-pass — token-efficient by design (route heavy work to smaller models, isolate sub-agent context). Distilled from Fable to reinforce the Opus harness. - Miguok/fable-harness",,2026-07-05,2026,Miguok/fable-harness,GitHub,,,,github-api,Miguok/fable-harness,191,33,1,"Make Claude Code work like a disciplined engineer: OODA, multi-party adversarial review, tiered model routing, fail-then-pass — token-efficient by design (route heavy work to smaller models, isolate sub-agent context). Distilled from Fable to reinforce the Opus harness.",MIT,2026-07-05T05:57:40Z,2026-07-18T06:00:43Z,,,2026-07-18T08:16:45+00:00
ale-0283,Mindwalk,https://github.com/cosmtrek/mindwalk,external,github.com,ok,200,https://github.com/cosmtrek/mindwalk,https://github.com/cosmtrek/mindwalk,text/html; charset=utf-8,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,780,47,5,A visualization tool that replays coding-agent sessions on a 3D map of your codebase.,MIT,2026-07-09T11:41:46Z,2026-07-18T08:11:16Z,,,2026-07-18T08:16:45+00:00
ale-0284,Waggle,https://github.com/modiqo/waggle,external,github.com,ok,200,https://github.com/modiqo/waggle,https://github.com/modiqo/waggle,text/html; charset=utf-8,"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,821,141,0,"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.",Apache-2.0,2026-07-08T04:33:09Z,2026-07-18T08:02:42Z,,,2026-07-18T08:16:45+00:00
ale-0285,Jacquard,https://github.com/jbwinters/jacquard-lang,external,github.com,ok,200,https://github.com/jbwinters/jacquard-lang,https://github.com/jbwinters/jacquard-lang,text/html; charset=utf-8,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,0,Jacquard is a small programming language designed for a regime in which most code is written by machine-learning models and reviewed by people.,Apache-2.0,2026-07-06T23:14:47Z,2026-07-18T05:05:56Z,,,2026-07-18T08:16:45+00:00
ale-0286,Agentic Verification of Software Systems,https://arxiv.org/abs/2511.17330,external,arxiv.org,ok,200,https://arxiv.org/abs/2511.17330,https://doi.org/10.1145/3808164,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0287,"A Trace-Based Assurance Framework for Agentic AI Orchestration: Contracts, Testing, and Governance",https://arxiv.org/abs/2603.18096,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.18096,https://doi.org/10.5220/0014840300004015,text/html; charset=utf-8,"[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-18T08:16:45+00:00
ale-0288,Self-Evolving Agents with Anytime-Valid Certificates,https://arxiv.org/abs/2607.00871,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.00871,https://arxiv.org/abs/2607.00871,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0289,Delayed Verification Destabilizes Multi-Agent LLM Belief,https://arxiv.org/abs/2606.27409,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.27409,https://arxiv.org/abs/2606.27409,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0290,Lean4Agent: Formal Modeling and Verification for Agent Workflow and Trajectory,https://arxiv.org/abs/2606.06523,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.06523,https://arxiv.org/abs/2606.06523,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0291,"Regimes: An Auditable, Held-Out-Gated Improvement Loop",https://arxiv.org/abs/2606.10241,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.10241,https://arxiv.org/abs/2606.10241,text/html; charset=utf-8,"[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-18T08:16:45+00:00
ale-0292,Agentic CLEAR: Automating Multi-Level Evaluation of LLM Agents,https://arxiv.org/abs/2605.22608,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.22608,https://aclanthology.org/2026.acl-demo.74/,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0293,Diagnosis-Driven Automatic Repair for Agentic Workflow via Symbolic Inference,https://arxiv.org/abs/2607.02882,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.02882,https://arxiv.org/abs/2607.02882,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0294,SkillCoach: Self-Evolving Rubrics for Evaluating and Enhancing Agentic Skill-Use,https://arxiv.org/abs/2607.01874,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.01874,https://arxiv.org/abs/2607.01874,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0295,SWE-Doctor: Guiding Software Engineering Agents with Runtime Diagnosis from Bug Reproduction Tests,https://arxiv.org/abs/2607.00990,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.00990,https://arxiv.org/abs/2607.00990,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0296,AgentTether: Graph-Guided Diagnosis and Runtime Intervention for Reliable LLM Agent Operation,https://arxiv.org/abs/2607.06273,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.06273,https://arxiv.org/abs/2607.06273,text/html; charset=utf-8,[2607.06273] AgentTether: Graph-Guided Diagnosis and Runtime Intervention for Reliable LLM Agent Operation,"Large language model (LLM) agents are increasingly used for multi-step, stateful tool-use tasks, yet production reliability remains limited. Unlike static software repair, agent repair must recover dynamic trajectories whose early decisions can propagate into later errors and external state changes. Existing automatic remedies address only part of this problem: blind retry adds no diagnosis, outcome feedback says whether a run failed but not where or why, and self-reflection often lacks grounded evidence to prevent the same failure from recurring. We present AgentTether, a run-time repair framework that automates post-run diagnosis and guided recovery without modifying the underlying agent or environment. AgentTether abstracts each run into Transition Units, links them through a dependency-aware Critical Transition Graph, and localizes failure-critical subtrajectories by combining an offline normal-behavior model with a run-local graph detector. It then converts the localized cause into behavior-scoped guidance backed by cross-iteration Repair Memory, and can optionally apply guarded run-time intervention to keep the correction active during re-execution. The same design can be deployed as an offline diagnostic-and-guidance tool or as an online repair layer. We evaluate AgentTether on 261 tau-bench tasks across three domains with Qwen3.7-max, and test cross-model transfer on Banking with GPT-5.4. On the hardest Banking domain, AgentTether repairs 59.04% (49/83) of initially failed Qwen3.7-max tasks and 65.12% (56/86) of initially failed GPT-5.4 tasks. Overall, AgentTether improves repair effectiveness while reducing agent turns and end-to-end approach tokens, suggesting a practical reliability layer that can wrap existing agent deployments, reduce wasted re-execution, and improve recovery without retraining the agent.",Chenyu Zhao; Shenglin Zhang; Wenwei Gu; Yongqian Sun; Dan Pei; Chetan Bansal; Saravan Rajmohan; Minghua Ma,2026-07-07,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,,,2607.06273,,2026-07-18T08:16:45+00:00
ale-0297,SWE-Review: Closing the Loop on Issue Resolution with Agentic Code Review,https://arxiv.org/abs/2607.06065,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.06065,https://arxiv.org/abs/2607.06065,text/html; charset=utf-8,[2607.06065] SWE-Review: Closing the Loop on Issue Resolution with Agentic Code Review,"Coding agents increasingly generate pull requests (PRs) for real-world software issues, yet one-shot PR generation remains open-loop: the PR is proposed without systematic review, diagnosis, or revision. We introduce \textbf{SWE-Review}, a framework for closing this loop with agentic code review. Given an issue and an AI-generated PR, a reviewer agent explores the repository, decides whether the PR should be accepted, and provides structured feedback for revision. We evaluate this setting with our proposed \textbf{SWE-Review-Bench} to measure both review correctness and downstream revision usefulness. We further curate \textbf{SWE-Review-Traj} dataset to study broader applications of agentic review and fill the data-scarcity gap for open reviewer training. Experiments show that agentic review continuously improves PRs through a generate-review-revise loop, outperforms single-turn fixed-context review in both decision accuracy and resolve rate after revision, transfers beyond review to improve issue-resolution models, and enables effective and efficient test-time scaling. These results position agentic code review as a practical mechanism for moving AI coding agents from one-shot PR generation toward closed-loop issue resolution.",Ruoyu Wang; Jierun Chen; Shaowei Wang; Chaofan Tao; Sidi Yang; Yuxin Jiang; Kim-Hui Yap; Lifeng Shang; Xiaohui Li; Haoli Bai,2026-07-07,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,,,2607.06065,,2026-07-18T08:16:45+00:00
ale-0298,"Reason Less, Verify More: Deterministic Gates Recover a Silent Policy-Violation Failure Mode",https://arxiv.org/abs/2607.07405,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07405,https://arxiv.org/abs/2607.07405,text/html; charset=utf-8,"[2607.07405] Reason Less, Verify More: Deterministic Gates Recover a Silent Policy-Violation Failure Mode in Tool-Using LLM Agents","Tool-using LLM agents can violate the very policies they are deployed to enforce while appearing to complete the task successfully. In policy-permissive environments, a tool may execute any well-formed call even when the corresponding state transition is forbidden by domain policy. The result is a silent wrong state (a booking cancelled, a passenger count changed, a claim acted on without verification) that neither the tool nor the agent's self-report exposes. We study this failure mode in the $\tau^2$-bench airline domain. On a budget agent, 78% of observed failures are silent wrong-state failures with no tool error, and the aggregate failure rate is reproducible across disjoint seeds, not sampling noise. We then evaluate a lightweight intervention: deterministic, read-only pre-execution gates that inspect the proposed call and current state before allowing a write. A four-gate suite raises full-benchmark success from 29.6% to 42.0% on gpt-4o-mini (+12.4pp; paired task-level bootstrap P=0.0012), and the lift reproduces on a disjoint 15-seed set (+12.3pp; P=0.0008). The effect is concentrated where the gates fire: on the 26/50 firing tasks, success rises by +19.2pp, while movement on the 24 non-firing tasks does not exclude zero. Two negative controls (a self-enforcing retail domain and BFCL) bound the mechanism: gates help when tools are policy-permissive and add little where tools already self-enforce. As suggestive evidence, not a central claim, the same failure mode persists at the frontier: gpt-5.2 at default reasoning still attempts policy-violating writes, and the same suite improves success from 61.2% to 71.6% (+10.4pp; P=0.020; n=5, no replication). The contribution is a bounded evaluation and reliability result: deterministic gates do not guarantee task success, but they can deterministically prevent a known class of silent policy-violating writes at the action boundary.",Vikas Reddy; Sumanth Reddy Challaram; Abhishek Basu,2026-07-08,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.07405,,2026-07-18T08:16:45+00:00
ale-0299,Harnessing Code Agents for Automatic Software Verification,https://arxiv.org/abs/2607.06341,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.06341,https://arxiv.org/abs/2607.06341,text/html; charset=utf-8,[2607.06341] Harnessing Code Agents for Automatic Software Verification,"Formal verification offers the strongest guarantee of software correctness, but it does not scale: the proofs demanded by interactive theorem provers such as Coq require enormous expert effort. Large language models (LLMs) promise to generate these proofs automatically, yet existing approaches wire a fixed, human-designed proof strategy into the system and constrain the model to follow it (retrieving premises and predicting tactics one step at a time, or splitting goals by divide-and-conquer), and still prove only a fraction of their target theorems. We show that imposing such a strategy is unnecessary and limiting. Handing the whole lemma to a general LLM code agent (for example, Claude Code), free to choose its own approach, and wrapping it in a verification harness is both simpler and more effective, achieving full coverage: every targeted lemma proved, with no failures and no Coq expert intervention. The agent writes the proofs under feedback and hard constraints from the harness that keep each one sound (accepted only when the prover's kernel closes it), complete (no obligation left unproved or silently dropped), and terminating (no divergent tactics). We evaluate this harness plus code agent along three dimensions. (1) Core logic: on Iris, the state-of-the-art separation logic for concurrent and memory-manipulating programs, Aria proves all 4,257 lemmas of the four core modules and the 217 lemmas verifying Rust's standard libraries built on it, fully automatically. (2) Comparison with prior LLM provers: on reglang, where prior provers manage barely one in eight, Aria proves all 318. (3) Generality: on iris-lean, the unfinished Lean 4 port of Iris, it proves 72 not-yet-ported lemmas, showing the approach is not specific to Coq. A state-of-the-art model (Claude Opus 4.7) can write proofs for verified software development fully and automatically.",Shuangxiang Kan; Shuanglong Kan; Sebastian Ertel,2026-07-07,2026,arXiv,arXiv,,,cs.FL,arxiv-api,,,,,,,,,2607.06341,,2026-07-18T08:16:45+00:00
ale-0300,LLM-as-a-Verifier: A General-Purpose Verification Framework,https://arxiv.org/abs/2607.05391,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.05391,https://arxiv.org/abs/2607.05391,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0301,From Prompts to Contracts: Harness Engineering for Auditable Enterprise LLM Agents,https://arxiv.org/abs/2607.08028,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08028,https://arxiv.org/abs/2607.08028,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0302,From Noisy Traces to Root Causes: Structural Trajectory Analysis and Causal Extraction for Agent Optimization,https://arxiv.org/abs/2607.07702,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07702,https://arxiv.org/abs/2607.07702,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0303,Who Broke the System? Failure Localization in LLM-Based Multi-Agent Systems,https://arxiv.org/abs/2607.07989,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07989,https://arxiv.org/abs/2607.07989,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0304,3100 Opinions on Code Review in an AI World: Building Causal Theory from Practitioner Discourse,https://arxiv.org/abs/2607.07980,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07980,https://arxiv.org/abs/2607.07980,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0305,Persuasion Attacks Can Decrease Effectiveness of CoT Monitoring,https://arxiv.org/abs/2607.08066,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08066,https://arxiv.org/abs/2607.08066,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0306,Physics-Audited Agentic Discovery in Scientific Machine Learning,https://arxiv.org/abs/2607.07379,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07379,https://arxiv.org/abs/2607.07379,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0307,Bug Report Specification Refinement with Trajectory Guidance for Automated Program Repair,https://arxiv.org/abs/2607.07882,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07882,https://arxiv.org/abs/2607.07882,text/html; charset=utf-8,[2607.07882] Bug Report Specification Refinement with Trajectory Guidance for Automated Program Repair,"Bug reports serve as task specifications for repository-level automated program repair (APR) agents, but they often describe only the observed failure and omit repair-relevant information such as the failure-inducing behavior, behavioral requirement, and implementation scope. As a result, a repair agent may inspect irrelevant code, infer an incorrect requirement, or generate a patch that addresses the reported symptom without restoring the intended repository behavior. We present TrajSpec, a trajectory-guided approach for repository-supported bug report specification refinement. Given an original report and a pre-fix repository, TrajSpec runs a trajectory-collection agent and uses the resulting unverified trajectory as a source of trajectory-derived specification evidence. It organizes this evidence into a three-level representation consisting of a high-level interpretation of the issue, diagnostic findings supporting that interpretation, and concrete repository observations. TrajSpec then generates a draft refined report and applies repository-based review to remove unsupported claims, revise uncertain claims, and add repository-supported details. We evaluate TrajSpec on all 300 SWE-Bench Lite instances using Mini-SWE-Agent V2. TrajSpec's refined reports improve Pass@1 from 41.00% to 59.67% with GPT-5-mini and from 54.67% to 64.33% with MiniMax M2.5. On a stratified sample of 100 instances, TrajSpec's refined reports also improve Pass@1 from 41.00% to 71.00% with Agentless and from 47.00% to 72.00% with AutoCodeRover. Ablation results show that removing repository-based review or the hierarchical evidence representation reduces Pass@1 from 59.67% to 48.00% and 47.67%, respectively. Overall, TrajSpec provides actionable repository-supported context that consistently improves repair performance.",S M Farah Al Fahim; Md Nakhla Rafi; Md Ahasanuzzaman; Zeyang Ma; Dong Jae Kim; Shaowei Wang; Tse-Hsun; Chen,2026-07-08,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,,,2607.07882,,2026-07-18T08:16:45+00:00
ale-0308,Failure as a Process: An Anatomy of CLI Coding Agent Trajectories,https://arxiv.org/abs/2607.09510,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.09510,https://arxiv.org/abs/2607.09510,text/html; charset=utf-8,[2607.09510] Failure as a Process: An Anatomy of CLI Coding Agent Trajectories,"Large language model (LLM) coding agents are increasingly deployed to autonomously perform software engineering tasks in terminal-based environments, making their reliability a growing concern. Existing empirical studies investigate why coding agents fail, yet they largely treat failure as a final outcome rather than a temporal process, providing limited insight into how failures emerge, evolve, and become unrecoverable. We present the first large-scale empirical study of CLI coding-agent failure trajectories, introducing a process-oriented framework that analyzes failure through its onset, evolution, and recovery across execution trajectories. We first collect 3,843 execution trajectories generated by seven frontier models across three coding-agent scaffolds (OpenHands, MiniSWE, and Terminus2) on Terminal-Bench, then carefully filter them to obtain 1,794 complete and valid trajectories for manual annotation (over 63,000 execution steps), from which we derive 14 findings spanning failure occurrence, root causes, recovery, and cross-system consistency. Our findings show that coding-agent failures are predominantly driven by epistemic errors, typically begin within the first few execution steps, and often remain hidden until recovery is no longer possible, suggesting that improving coding-agent reliability requires earlier validation and intervention rather than relying solely on final-outcome evaluation.",Xiangxin Zhao; Han Li; Shuaiting Li; Tianyi Zhao; Earl T. Barr; Federica Sarro; He Ye,2026-07-10,2026,arXiv,arXiv,,"12 pages, 6 figures",cs.SE,arxiv-api,,,,,,,,,2607.09510,,2026-07-18T08:16:45+00:00
ale-0309,Agentic Proof and Property-Based Testing via Property-Templates,https://arxiv.org/abs/2607.09072,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.09072,https://arxiv.org/abs/2607.09072,text/html; charset=utf-8,[2607.09072] Agentic Proof and Property-Based Testing via Property-Templates in Data-Intensive Computing,"As the cost of code generation becomes cheaper with AI, the new bottleneck in software engineering has shifted to intent specification and validation. Overcoming this durability crisis of AI-driven coding requires more than traditional fuzzing: each candidate property must be proven correct over a model and shown to hold on the real implementation, making formal proof and systematic property-based testing (PBT) complementary. However, validating properties this way at scale requires solving two subproblems: verifying candidate properties and operationalizing PBT without AI hallucination. We hypothesize that recurring property patterns, cast as property templates--abstract, parameterized forms with holes--address both at once. This paper investigates recurring property patterns in Apache Spark. In data-intensive scalable computing systems, correctness properties arise from the principles of data partition, computation decomposition, and dataflow computation. For instance, aggregation decomposition relates a global function executed on the entire dataset to a local function followed by a recombiner. We design an agentic, dual-track validation framework that uses property templates to formally verify correctness in the Lean 4 theorem prover and instantiate PBT templates as executable PySpark tests. Our evaluation shows that property templates increase agentic proof engineering success by up to 2.6x (1.6x on average) and reduce proof hallucinations by 59%. Template-guided PBT synthesis reduces intent misalignments from 22 to 1 and cuts synthesis cost by up to 5.7x (3.8x on average). Template-guided synthesis further exceeds a state-of-the-art Spark fuzzer and approaches unguided LLM-based PBT on code coverage. Finally, comparing the two tracks is informative: when a proof succeeds yet a PBT finds a counterexample, the mismatch identifies a gap between the formal model and implementation.",Seongmin Lee; Yaoxuan Wu; Miryung Kim,2026-07-10,2026,arXiv,arXiv,,"12 pages, 7 figures, 4 tables; supplementary material included as ancillary file",cs.SE,arxiv-api,,,,,,,,,2607.09072,,2026-07-18T08:16:45+00:00
ale-0310,AgentCheck: A Reproduce-Intervene-Mitigate Workbench for LLM Agents over MCP,https://arxiv.org/abs/2607.11098,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.11098,https://arxiv.org/abs/2607.11098,text/html; charset=utf-8,[2607.11098] AgentCheck: A Reproduce-Intervene-Mitigate Workbench for LLM Agents over MCP,"Tool-using LLM agents are mostly evaluated assuming all tools work. When a tool times out, returns a week-stale value, or has its description poisoned in deployment, the developer needs a controlled way to reproduce the failure, test a fix, and confirm the fix worked before deployment. We present AgentCheck, an open-source web workbench that turns an MCP server into an intervention surface. AgentCheck runs an agent against its real tools and records every tool response, then re-runs the agent with the response perturbed by a fault (12 types) injector. Matching tool calls are replayed from cache, and later tool calls go live after the agent diverges. This yields a reproduce-intervene-confirm loop: the developer toggles a mitigation, re-runs against the identical fault, and sees if the failure goes away. Scoring has two parts: deterministic pass/fail rules, plus an LLM judge for interpretive labels, validated against human annotations. Across five agents, the best passes 105/120 scenarios and the weakest only 77. The failures are usually silent, confident use of incorrect tool outputs rather than crashes. On the weakest agent, a retry mitigation raises success on timeout error faults from as few as 30% of cases to 100%, whereas stale-data faults remain near 3-4 of 10 regardless of the mitigation. AgentCheck makes these failure modes reproducible, comparable, and verifiable before deployment.",Aritra Mazumder; Nusrat jahan Lia,2026-07-13,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,,,2607.11098,,2026-07-18T08:16:45+00:00
ale-0311,Latent Programming Horizons in Coding Agents,https://arxiv.org/abs/2607.05188,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.05188,https://arxiv.org/abs/2607.05188,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0312,Why evaluate agents,https://adk.dev/evaluate/,external,adk.dev,ok,200,https://adk.dev/evaluate/,https://adk.dev/evaluate/,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0313,Structured Feedback Improves Repair in an LLM Agent Loop,https://arxiv.org/abs/2607.14167,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14167,https://arxiv.org/abs/2607.14167,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0314,Copy-on-Write Scoring: Application-Specific Agent Evaluations,https://arxiv.org/abs/2607.14336,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14336,https://arxiv.org/abs/2607.14336,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0315,The Prover Is the Judge: Verified Security Software from AI Coding Agents in Ada/SPARK,https://arxiv.org/abs/2607.14340,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14340,https://arxiv.org/abs/2607.14340,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0316,GLEAN: Guideline-Grounded Evidence Accumulation for High-Stakes Agent Verification,https://arxiv.org/abs/2603.02798,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.02798,https://arxiv.org/abs/2603.02798,text/html; charset=utf-8,[2603.02798] Guideline-Grounded Evidence Accumulation for High-Stakes Agent Verification,"As LLM-powered agents have been used for high-stakes decision-making, such as clinical diagnosis, it becomes critical to develop reliable verification of their decisions to facilitate trustworthy deployment. Yet, existing verifiers usually underperform owing to a lack of domain knowledge and limited calibration. To address this, we establish GLEAN, an agent verification framework with Guideline-grounded Evidence Accumulation that compiles expert-curated protocols into trajectory-informed, well-calibrated correctness signals. GLEAN evaluates the step-wise alignment with domain guidelines and aggregates multi-guideline ratings into surrogate features, which are accumulated along the trajectory and calibrated into correctness probabilities using Bayesian logistic regression. Moreover, the estimated uncertainty triggers active verification, which selectively collects additional evidence for uncertain cases via expanding guideline coverage and performing differential checks. We empirically validate GLEAN with agentic clinical diagnosis across three diseases from the MIMIC-IV dataset, surpassing the best baseline by 12% in AUROC and 50% in Brier score reduction, which confirms the effectiveness in both discrimination and calibration. In addition, the expert study with clinicians recognizes GLEAN's utility in practice.",Yichi Zhang; Nabeel Seedat; Yinpeng Dong; Peng Cui; Jun Zhu; Mihaela van de Schaar,2026-03-03,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2603.02798,,2026-07-18T08:16:45+00:00
ale-0317,Zombie Agents: Detecting Semantic Livelock in Long-Horizon Autonomous Software,https://doi.org/10.1145/3805760.3814895,external,doi.org,restricted,403,https://doi.org/10.1145/3805760.3814895,https://doi.org/10.1145/3805760.3814895,text/html; charset=UTF-8,,,Simarjot Khanna,2026-07,2026,Proceedings of the 3rd ACM International Conference on AI-Powered Software (AIware '26),Association for Computing Machinery,10.1145/3805760.3814895,Published at AIware 2026; metadata verified from the author-supplied camera-ready paper because the DOI landing page restricted automated access.,,ACM DOI and camera-ready paper,,,,,,,,,,restricted_or_rate_limited,2026-07-18T08:16:45+00:00
ale-0318,The lethal trifecta for AI agents,https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/,external,simonwillison.net,ok,200,https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/,https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/,text/html; charset=utf-8,"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-18T08:16:45+00:00
ale-0319,Prompt injection series,https://simonwillison.net/series/prompt-injection/,external,simonwillison.net,ok,200,https://simonwillison.net/series/prompt-injection/,https://simonwillison.net/series/prompt-injection/,text/html; charset=utf-8,Simon Willison: Prompt injection,,Simon Willison,,,,Simon Willison’s Weblog,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0320,Agentic AI - Threats and Mitigations,https://genai.owasp.org/resource/agentic-ai-threats-and-mitigations/,external,genai.owasp.org,ok,200,https://genai.owasp.org/resource/agentic-ai-threats-and-mitigations/,https://genai.owasp.org/resource/agentic-ai-threats-and-mitigations/,text/html; charset=UTF-8,Agentic AI - OWASP Lists Threats and Mitigations,"Explore key threats and mitigation strategies for agentic AI, focusing on security measures to address vulnerabilities in AI applications and their potential risks.",OWASPGenAIProject Editor,,,,OWASP Gen AI Security Project,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0321,Designing AI agents to resist prompt injection,https://openai.com/index/designing-agents-to-resist-prompt-injection/,external,openai.com,restricted,403,https://openai.com/index/designing-agents-to-resist-prompt-injection/,https://openai.com/index/designing-agents-to-resist-prompt-injection/,text/html; charset=UTF-8,,,,,,,OpenAI,,,,domain-fallback,,,,,,,,,,restricted_or_rate_limited,2026-07-18T08:16:45+00:00
ale-0322,sandbox-runtime,https://github.com/anthropic-experimental/sandbox-runtime,external,github.com,ok,200,https://github.com/anthropic-experimental/sandbox-runtime,https://github.com/anthropic-experimental/sandbox-runtime,text/html; charset=utf-8,"GitHub - anthropic-experimental/sandbox-runtime: A lightweight sandboxing tool for enforcing filesystem and network restrictions on arbitrary processes at the OS level, without requiring a container. · GitHub","A lightweight sandboxing tool for enforcing filesystem and network restrictions on arbitrary processes at the OS level, without requiring a container. - anthropic-experimental/sandbox-runtime",,2025-10-20,2025,anthropic-experimental/sandbox-runtime,GitHub,,,,github-api,anthropic-experimental/sandbox-runtime,4695,364,135,"A lightweight sandboxing tool for enforcing filesystem and network restrictions on arbitrary processes at the OS level, without requiring a container.",Apache-2.0,2025-10-20T02:52:10Z,2026-07-17T22:13:49Z,,,2026-07-18T08:16:45+00:00
ale-0323,E2B,https://github.com/e2b-dev/E2B,external,github.com,ok,200,https://github.com/e2b-dev/E2B,https://github.com/e2b-dev/E2B,text/html; charset=utf-8,"GitHub - e2b-dev/E2B: Open-source, secure environment with real-world tools for enterprise-grade agents. · GitHub","Open-source, secure environment with real-world tools for enterprise-grade agents. - e2b-dev/E2B",,2023-03-04,2023,e2b-dev/E2B,GitHub,,,,github-api,e2b-dev/E2B,13022,967,54,"Open-source, secure environment with real-world tools for enterprise-grade agents.",Apache-2.0,2023-03-04T13:41:18Z,2026-07-18T06:54:44Z,,,2026-07-18T08:16:45+00:00
ale-0324,Modal Sandboxes,https://modal.com/docs/guide/sandboxes,external,modal.com,ok,200,https://modal.com/docs/guide/sandboxes,https://modal.com/docs/guide/sandboxes,text/html,Sandboxes | Modal Docs,"This page is a high-level guide to Sandboxes, secure containers for executing untrusted user or agent code on Modal.",,,,,Modal,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0325,Daytona,https://www.daytona.io/,external,www.daytona.io,ok,200,https://www.daytona.io/,https://www.daytona.io/,text/html,Daytona - Secure Infrastructure for Running AI-Generated Code,"Deploy Al code with confidence using Daytona's lightning-fast infrastructure. 90ms environment creation, stateful operations, and enterprise-grade security.",,,,,daytona.io,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0326,peerd,https://github.com/NotASithLord/peerd,external,github.com,ok,200,https://github.com/NotASithLord/peerd,https://github.com/NotASithLord/peerd,text/html; charset=utf-8,"GitHub - NotASithLord/peerd: The first AI agent harness native to the browser. A browser extension that runs a full agent loop where you already work: it drives your tabs, spins up sandboxed compute (JS notebooks, WASM Linux VMs, client-side apps), and shares what it builds peer-to-peer. BYOK, no backend, no telemetry. · GitHub","The first AI agent harness native to the browser. A browser extension that runs a full agent loop where you already work: it drives your tabs, spins up sandboxed compute (JS notebooks, WASM Linux VMs, client-side apps), and shares what it builds peer-to-peer. BYOK, no backend, no telemetry. - NotASithLord/peerd",,2026-06-22,2026,NotASithLord/peerd,GitHub,,,,github-api,NotASithLord/peerd,361,35,21,"The first AI agent harness native to the browser. A browser extension that runs a full agent loop where you already work: it drives your tabs, spins up sandboxed compute (JS notebooks, WASM Linux VMs, client-side apps), and shares what it builds peer-to-peer. BYOK, no backend, no telemetry.",Apache-2.0,2026-06-22T05:55:13Z,2026-07-17T20:50:35Z,,,2026-07-18T08:16:45+00:00
ale-0327,When Claws Remember but Do Not Tell: Stealthy Memory Injection in Persistent Personal Agents,https://arxiv.org/abs/2607.05189,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.05189,https://arxiv.org/abs/2607.05189,text/html; charset=utf-8,[2607.05189] When Claws Remember but Do Not Tell: Stealthy Memory Injection in Persistent Personal Agents,"Persistent personal agents combine long-term memory with access to users' external environments, enabling personalized foreground assistance and proactive background execution. This integration also creates a new path to compromise: untrusted external content can be silently written into persistent memory and later reused as trusted state. We study this threat as stealth memory injection, in which a remote black-box adversary delivers a single email payload that must induce the agent to write poisoned memory, stay hidden in the agent's response to the user, and affect future behavior. We introduce WhisperBench, a 108-case benchmark spanning five risk categories and both fact and preference poisoning. Built on a real IMAP/SMTP workflow and an authentic email agent skill, it enables full-cycle evaluation of stealth memory injection attacks. To enable this black-box attack under single-email delivery and without runtime feedback, we propose MemGhost, a one-shot payload generation framework. MemGhost uses an environment proxy to emulate persistent-agent execution and an objective proxy to convert memory adoption and conversational stealth into dense rubric-based rewards, then trains the attacker policy with supervised fine-tuning and reinforcement learning. Across 56 held-out test cases, MemGhost achieves 87.5% end-to-end success on OpenClaw with GPT-5.4 and 71.4% on Claude Code SDK with Sonnet 4.6. It also transfers across personal-agent architectures (NanoClaw and Hermes Agent) and memory backends (filesystem and vector-based Mem0), and remains effective against input-level, model-level, and system-level defenses. These results suggest that persistent memory can turn ordinary external processing into a practical pathway for long-term agent compromise.",Yechao Zhang; Shiqian Zhao; Jiawen Zhang; Jie Zhang; Gelei Deng; Xiaogeng Liu; Chaowei Xiao; Tianwei Zhang,2026-07-06,2026,arXiv,arXiv,,"25 pages, 8 figures. Preprint",cs.CR,arxiv-api,,,,,,,,,2607.05189,,2026-07-18T08:16:45+00:00
ale-0328,Your Agent's Memories Are Not Its Own: Forged Reasoning Attacks on LLM Agent Memory and Defenses,https://arxiv.org/abs/2607.05029,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.05029,https://arxiv.org/abs/2607.05029,text/html; charset=utf-8,[2607.05029] Your Agent's Memories Are Not Its Own: Forged Reasoning Attacks on LLM Agent Memory and Defenses,"Persistent memory has enabled large language model (LLM) agents to store factual knowledge, prior decisions, reasoning histories, tool usage information, and context. While this has improved the agent's functionality and continuity across tasks, it has also introduced a new attack surface: the agent's own reasoning history. In this paper, we introduce the Forged Amplifying Rationale Memory Attack (FARMA), which poisons an agent's remembered reasoning rather than its factual knowledge. It inserts forged reasoning traces using evasive language that bypasses keyword-based defenses, then amplifies them through self-referential reinforcement that defeats consensus-based defenses. To address FARMA, we introduce SENTINEL, a layered defense pipeline to detect forged reasoning entries. Its central component is the Reasoning Guard that structurally analyzes candidate entries for forgery using five weighted signals. We evaluate FARMA and SENTINEL across multiple agents and different LLM models with 50 trials and show that FARMA achieves an attack success rate of up to 100% under baseline conditions and is capable of defeating defense mechanisms like keyword filter and A-MemGuard. Our evaluation also shows that SENTINEL reduces FARMA's attack success rate to as low as 0% with no false positives observed across 326 benign agent traces. Our work demonstrates the need to protect not only an agent's retrieved content but also the integrity of its reasoning history.",Neeraj Karamchandani; Piyush Nagasubramaniam; Sencun Zhu; Dinghao Wu,2026-07-06,2026,arXiv,arXiv,,"Preprint. 10 pages, 2 figures, 4 tables",cs.CR,arxiv-api,,,,,,,,,2607.05029,,2026-07-18T08:16:45+00:00
ale-0329,Distributed Attacks in Persistent-State AI Control,https://arxiv.org/abs/2607.02514,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.02514,https://arxiv.org/abs/2607.02514,text/html; charset=utf-8,[2607.02514] Distributed Attacks in Persistent-State AI Control,"As AI coding agents become more autonomous, they increasingly ship code iteratively, with the codebase persisting across sessions. This persistence creates a new attack surface: a misaligned or prompt-injected agent can distribute attacks across pull requests (PRs) and time its payload for the PR with the best natural cover. To study the resulting dynamics, we introduce Iterative VibeCoding, a setting for AI control, the study of safely deploying capable but potentially untrusted AI. In Iterative VibeCoding, a coding agent builds software over a sequence of PRs in a persistent codebase while pursuing a covert side task. Our benchmark includes two task families: CLI tools and Flask web services, across 20 total task variations. We use Claude Sonnet 4.5 as the attack agent and GPT-4o as the monitor. We compare gradual attacks, which distribute the side task across PRs, against non-gradual attacks concentrated in a single PR. No single monitor is robust to both: which strategy evades best (success while evading the monitor) depends on the monitor type, so a defender cannot close off both gradual and non-gradual attacks with any one monitor. High evasion (>= 65%) generalizes across model attack agent backends (Sonnet 4.5, Gemini 3.1 Pro, Kimi K2.5), confirming this is a property of the persistent-state attack surface rather than a single model's capability. Evasion also remains high across state-of-the-art monitor models and the gap between gradual and non-gradual evasion widens for more capable models. We introduce a stateful link-tracker monitor that tracks suspicious buildup across PRs. On both task families, it detects gradual attacks substantially better than diff monitors that merely see more accumulated history. Combining this stronger monitor with trajectory monitors in a four-monitor ensemble reduces gradual-attack evasion from 93% under the weakest standard diff monitor to 47%.",Josh Hills; Ida Caspary; Asa Cooper Stickland,2026-07-02,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.02514,,2026-07-18T08:16:45+00:00
ale-0330,ElephantAgent: Contextual State Continuity in Agentic Systems,https://arxiv.org/abs/2607.01919,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.01919,https://arxiv.org/abs/2607.01919,text/html; charset=utf-8,[2607.01919] ElephantAgent: Contextual State Continuity in Agentic Systems,"Agentic systems enhance their capabilities by invoking external tools and maintaining persistent memory. However, these external dependencies introduce novel attack surfaces. Recent tool and memory poisoning attacks show that maliciously crafted tool descriptors and poisoned memory can covertly bias agent behavior. These threats reflect a deeper issue: the lack of verifiable continuity in the agent's contextual state for planning and execution. We present ElephantAgent, a protocol that enforces Contextual State Continuity to defend against contextual state poisoning. Inspired by prior state-continuity mechanisms (e.g., Nimble), ElephantAgent extends this protection to the evolving contextual state of agentic systems. We define the contextual state as the bounded, security-critical subset of the agent's entire context (e.g., tool state and memory). Before processing each query, ElephantAgent recomputes the digest of the local contextual state and verifies it against the latest authorized digest. Using replicated trusted hardware, ElephantAgent maintains a linearizable ledger of authorized contextual state transitions and detects out-of-band state tampering. To handle in-band semantic abuse, ElephantAgent additionally provides Historical Traceability, enabling conditional post-hoc audit and recovery to a known-good prior state.",Jiankai Jin; Xiangzheng Zhang; Zhao Liu; Wenzhuo Xu; Dongdong Yang; Deyue Zhang; Quanchen Zou,2026-07-02,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.01919,,2026-07-18T08:16:45+00:00
ale-0331,Cloudflare security-audit-skill,https://github.com/cloudflare/security-audit-skill,external,github.com,ok,200,https://github.com/cloudflare/security-audit-skill,https://github.com/cloudflare/security-audit-skill,text/html; charset=utf-8,"GitHub - cloudflare/security-audit-skill: A coding-agent skill for multi-phase security audits with independently verified, machine-readable findings · GitHub","A coding-agent skill for multi-phase security audits with independently verified, machine-readable findings - cloudflare/security-audit-skill",,2026-06-18,2026,cloudflare/security-audit-skill,GitHub,,,,github-api,cloudflare/security-audit-skill,2566,190,2,"A coding-agent skill for multi-phase security audits with independently verified, machine-readable findings",MIT,2026-06-18T14:08:44Z,2026-07-18T07:43:40Z,,,2026-07-18T08:16:45+00:00
ale-0332,The Balkanization of Execution-Security Research for AI Coding Agents,https://arxiv.org/abs/2607.05743,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.05743,https://arxiv.org/abs/2607.05743,text/html; charset=utf-8,"[2607.05743] The Balkanization of Execution-Security Research for AI Coding Agents: Isolation, Access Control, and Time-of-Check-to-Time-of-Use Vulnerabilities","AI coding agents now read repositories, call tools, and execute shell commands with limited human oversight, and a fast-growing body of work studies whether the execution layer around them is actually safe. That literature is scattered. Papers on sandbox isolation, capability and access control, policy enforcement, time-of-check-to-time-of-use (TOCTOU) races, Model Context Protocol (MCP) threats, identity delegation, execution provenance, network egress control, and static analysis of agent-generated code are published independently and rarely cite one another. We systematize 39 papers published between 2023 and 2026 into 17 categories, each verified directly against its source. The same verification protocol also confirms four disclosed, patched CVEs directly affecting production agent harnesses. Reading across categories surfaces five cross-cutting gaps that no single paper addresses. (1) Isolation architectures and capability models are almost never evaluated against one another on a shared benchmark. (2) Policy-enforcement studies report failure rates from 69% to 98% of real denylists, yet no isolation paper re-evaluates its own defense under that adversarial setting. (3) TOCTOU and MCP threats are analyzed as separate literatures despite both being instances of the same state-validation problem. (4) Every enforcement mechanism assumes an honest policy author, leaving policy-authoring error itself unaddressed. (5) Benign but out-of-scope agent actions occurring at rates up to 17.1% under realistic prompting are addressed by no access-control or capability paper in the corpus. Existing broader surveys of agentic AI security discuss sandboxing only as one item among many defenses, leaving execution security without a dedicated systematization. This paper is written to fill that gap. We conclude with a research agenda directed at the five gaps.",Mohammadreza Rashidi,2026-07-07,2026,arXiv,arXiv,,"18 pages, 15 figures, 6 tables. Systematizes 39 execution-security papers (2023-2026) into 17 verified categories. Machine-readable corpus and verification script released as a supplementary artifact",cs.CR,arxiv-api,,,,,,,,,2607.05743,,2026-07-18T08:16:45+00:00
ale-0333,Context-to-Execution Integrity for LLM Agents,https://arxiv.org/abs/2607.06000,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.06000,https://arxiv.org/abs/2607.06000,text/html; charset=utf-8,[2607.06000] Context-to-Execution Integrity for LLM Agents,"Language-model agents read attacker-writable context to solve tasks. Tool execution needs a separate authority check for protected sink fields, sink-interpreted payloads, and the invocation event. Context-to-Execution Integrity (CXI) is an execution-boundary system for this setting. Policies mark protected sink fields, typed releases carry narrow validated values from writable context to specific destinations, opaque data slots keep evidence as data, and a deterministic gate admits a call only after field authority, exact-effect authorization, and invocation authority all bind to the same action manifest. We evaluate CXI on open-weight field-projection runs, AgentDojo live episodes, a code-agent exact-effect benchmark, manifest-bound ledger faults, proposal-pressure controls, and hosted/API compatibility traces. AgentDojo covers 720 live episodes and 1,739 LLM calls; the code-agent benchmark covers 400 repository episodes with exact-effect authorization and lease-bound execution, yielding 231 safe task completions and zero observed field, effect, or invocation escapes. The accounting reports parser outcomes, authorization outcomes, and task-quality outcomes together with the admission-integrity result. Across the evaluated sinks, CXI admits execution only when field, effect, and invocation authority bind to the same action manifest.",Igor Santos-Grueiro,2026-07-07,2026,arXiv,arXiv,,20 pages,cs.CR,arxiv-api,,,,,,,,,2607.06000,,2026-07-18T08:16:45+00:00
ale-0334,When Agents Remember Too Much: Memory Poisoning Attacks on Large Language Model Agents,https://arxiv.org/abs/2607.06595,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.06595,https://arxiv.org/abs/2607.06595,text/html; charset=utf-8,[2607.06595] When Agents Remember Too Much: Memory Poisoning Attacks on Large Language Model Agents,"Personal AI agents powered by large language models can reason and act using available tools to access emails, manage calendars, and push code to remote repositories, all with minimal oversight. When augmented with long-term memory, an agent can recall specific details relevant to the current task, reducing the need for large context windows. Currently, long-term memory agents tend to fall into two distinct domains: conversational and action-planning agents. Personal assistant agents sit at the convergence of these two domains and handle sensitive information while interacting with untrusted information sources, creating previously unaccounted security vulnerabilities. In this work, we introduce the novel attack vector, GhostWriter, which exploits current memory subsystems in tool-using personal agents to poison their memory store. GhostWriter operates in two phases: injection, where an adversary sends a hidden attack payload to the target agent; and activation, in which the poisoned memory is retrieved. We show that GhostWriter achieves near-universal injection rates of approximately 98% and a high average activation rate of approximately 60% against state-of-the-art agents. This attack is possible due to the lack of security-focused memory governance. In response, we propose Agentic Memory Sentry (AM-Sentry), which leverages two mitigation techniques: a memory-saving policy and a memory-retrieval screen. Our experiments show that AM-Sentry dramatically reduces GhostWriter's success rate while preserving agent utility.",George Torres; Sharad Shrestha; Satyajayant Misra,2026-07-06,2026,arXiv,arXiv,,,cs.CR,arxiv-api,,,,,,,,,2607.06595,,2026-07-18T08:16:45+00:00
ale-0335,Token-Flow Firewall: Semantic Runtime Auditing for Persistent AI Agents,https://arxiv.org/abs/2607.08395,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08395,https://arxiv.org/abs/2607.08395,text/html; charset=utf-8,[2607.08395] Token-Flow Firewall: Semantic Runtime Auditing for Persistent AI Agents,"Persistent AI agents extend large language models (LLMs) beyond single-turn interaction into long-lived software systems. Unlike traditional chat assistants, unsafe content in these agents can propagate through persistent state, reusable skills, and tool-mediated interactions, creating a substantially larger semantic attack surface. We observe that most security-critical interactions in such agents are transmitted through natural-language token flows, including memory updates, tool arguments, retrieved files, and inter-component communications. This observation enables a new security formulation: unsafe behavior can be intercepted as risky semantic flows before reaching privileged runtime sinks. Based on this insight, we propose TokenWall, a runtime defense framework that acts as a semantic firewall over agent token flows. TokenWall performs boundary-aware semantic auditing over these flows, constructing structured source-sink audit records, applying lightweight local inspection before execution, and selectively escalating ambiguous high-risk cases to stronger arbitration modules. Unlike prior approaches that rely on sparse auditing or remote large-model oversight, TokenWall enables full-coverage pre-execution mediation while reducing remote arbitration and latency. Experiments on CIK-Bench show that TokenWall reduces attack success rate to 12.5% while maintaining a 97.4% benign executable pass rate without human confirmation. TokenWall further introduces only 0.69 seconds of additional latency on benign cases, demonstrating that semantic runtime containment can achieve a practical security-utility trade-off for persistent AI agents.",Puji Wang; Yingchen Zhang; Ruqing Zhang; Jiafeng Guo; Xueqi Cheng,2026-07-09,2026,arXiv,arXiv,,,cs.CR,arxiv-api,,,,,,,,,2607.08395,,2026-07-18T08:16:45+00:00
ale-0336,Prismata: Confining Cross-Site Prompt Injection in Web Agents,https://arxiv.org/abs/2607.08147,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08147,https://arxiv.org/abs/2607.08147,text/html; charset=utf-8,[2607.08147] Prismata: Confining Cross-Site Prompt Injection in Web Agents,"Autonomous web agents promise to automate everyday browsing tasks, but inherit one of the web's oldest attack surfaces. Cross-Site Scripting proved that mixing trusted and untrusted content is dangerous, even on benign pages. Agents resurface this risk by interpreting natural language as instructions, allowing third-party and user-generated content to hijack the agent via prompt injection. The core challenge is that deriving a task-specific security policy requires reasoning over page structure that is entangled with the attacker's content. We present Prismata, a defense enforcing contextual least privilege for web agents, constraining both what the agent sees and what it can do. Prismata's dynamic trust derivation produces permission labels for page content, with structural confinement guarantees, inspired by classical integrity models, that bound any labeling errors so that labels can only decrease in privilege and mislabelings are bounded. Prismata's mechanical confinement enforces these labels by redacting content and restricting agent capabilities. Importantly, these mechanisms require no developer annotations, so Prismata supports the long tail of websites. Across recent published web agent attacks, including adaptive variants, Prismata substantially reduces attack success while preserving benign task utility.",Corban Villa; Alp Eren Ozdarendeli; Sijun Tan; Raluca Ada Popa,2026-07-09,2026,arXiv,arXiv,,,cs.CR,arxiv-api,,,,,,,,,2607.08147,,2026-07-18T08:16:45+00:00
ale-0337,TRACE: A Two-Channel Robust Attribution Watermark via Complementary Embeddings for LLM-Agent Trajectories,https://arxiv.org/abs/2607.08400,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08400,https://arxiv.org/abs/2607.08400,text/html; charset=utf-8,[2607.08400] TRACE: A Two-Channel Robust Attribution Watermark via Complementary Embeddings for LLM-Agent Trajectories,"LLM agents reach users through resellers, who may rebrand a developer's agent or substitute a cheaper model. When provenance is disputed, attribution rests on the trajectory log (the record of tool calls, observations, and executed actions, not the model's reasoning), which the reseller stores and processes to meter usage. A watermark must therefore survive an adversary with full read/write access to the very evidence it is detected from; existing agent watermarks do not, as their attribution is read straight off that log. We present TRACE, to our knowledge the first agent watermark that is distortion-free in its action choices, self-synchronizing under deletion, and unconditionally invariant under rewriting. Deletion desynchronizes a position-derived key and rewriting alters content, so a deletion-robust key must come from content and a rewrite-robust key from position, and no single key serves both. A trajectory, however, has room for two watermarks. TRACE superposes a selection channel that sets which action is chosen, keyed on local content with a distortion-free sampler, so the agent's distribution is provably unchanged and detection resynchronizes after deletions, and a tally channel that sets how many records each decision group holds, keyed on the log's skeleton alone, which no rewriting can touch. We prove this behavioral watermark's signal is bought with decision entropy, each decision paying at least half its entropy and deterministic decisions nothing, and that erasing both channels forces the reseller to corrupt the trajectories it resells. On ToolBench and ALFWorld, TRACE matches the unwatermarked agent's success rate while its selection channel reaches detection scores near z = 100 on long-horizon trajectories, stays detectable under 70% step deletion, and keeps a tally channel exactly unchanged under LLM rewriting of any strength.",Zheng Gao; Xiaoyu Li; Xiaoyan Feng; Jiaojiao Jiang; Yang Song; Yulei Sui; Zhenchang Xing; Liming Zhu,2026-07-09,2026,arXiv,arXiv,,,cs.CR,arxiv-api,,,,,,,,,2607.08400,,2026-07-18T08:16:45+00:00
ale-0338,Beyond Attack-Success Rate: Action-Graded Severity Scale for Tool-Using AI Agents,https://arxiv.org/abs/2607.07474,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07474,https://arxiv.org/abs/2607.07474,text/html; charset=utf-8,[2607.07474] Beyond Attack-Success Rate: Action-Graded Severity Scale for Tool-Using AI Agents,"Agentic red-teaming benchmarks report whether an injected agent was compromised as a single bit: the attack succeeded, or it did not. We argue that this binary attack-success rate discards the information a defender most needs, namely how harmful the resulting action was. We introduce an action-graded harm rubric that scores an agent's tool-call trajectory on a seven-level ordinal scale (L0 to L6) according to whether the executed action was reversible, whether it crossed scope to reach another party, and whether it expanded privilege. We compute the scale two ways: a deterministic oracle that reads the trajectory and the attacker's stated goal, and a panel of three frontier language-model judges that read a tag-free account of the same trajectory. Across four victim models and two defenses on the AgentDojo workspace suite, severity grading exposes three cases the binary metric hides, including a defense that reports a zero attack-success rate while still permitting an externally visible cross-scope leak through an unfiltered tool. The judge panel reproduces the oracle with high ordinal agreement (Krippendorff's alpha = 0.91) but shares systematic blind spots that we characterize, most notably a failure to recognize escalation chains. Unlike prior work that provides harm taxonomies, harmful-task completion tests, execution-level safety benchmarks, or severity-aware simulation, our contribution is a reusable, trace-grounded severity instrument applied to the actual actions recorded in existing red-team logs. All code, prompts, and per-episode logs are released.",Harry Owiredu-Ashley,2026-07-08,2026,arXiv,arXiv,,"8 pages, 6 figures. Code and artifacts: https://github.com/Harry-Ashley/action-graded-severity",cs.CR,arxiv-api,,,,,,,,,2607.07474,,2026-07-18T08:16:45+00:00
ale-0339,Beware of Agentic Botnets: Scalable Untargeted Promptware Attacks via Universal and Transferable Adversarial HalluSquatting,https://arxiv.org/abs/2607.07433,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07433,https://arxiv.org/abs/2607.07433,text/html; charset=utf-8,[2607.07433] Beware of Agentic Botnets: Scalable Untargeted Promptware Attacks via Universal and Transferable Adversarial HalluSquatting,"The growing adoption of agentic LLM applications has introduced a new threat previously named as promptware. While prior work has established that adversaries can exploit direct channels to LLM applications to apply promptware under weak threat models, many applications do not provide any direct channels that could be exploited for prompt injection beyond the Internet. This raises a question: can attackers exploit LLM applications at scale without any direct channels in practical threat models? In this work, we show that the inherent tendency of LLMs to hallucinate resource identifiers can be exploited to amplify untargeted promptware attacks that pull adversarial prompts at scale and could be exploited to establish a botnet. We introduce adversarial hallucination squatting, a technique in which attackers identify trending resources (e.g., popular repositories, popular skills, etc.), compute the LLM distribution of hallucinations on the trending resource names, and preemptively register them to host adversarial prompts. By leveraging the predictability and transferability of hallucinations across foundational LLMs and to application layers, adversaries can significantly amplify the reach of untargeted promptware under weak threat models and establish a botnet by exploiting LLM applications to install a bot on the device that pulled the compromised hallucinated resource from the Inter. We empirically demonstrate that hallucinated resource generation occurs at high rates, up to 85% in repository cloning scenarios and up to 100% in skill installation, and that these hallucinations transfer between foundational models and different prompts. We demonstrate the practicality of adversarial hallucination squatting against various production LLM applications with integrated terminals in their set of tools, achieving remote tool execution and remote code execution.",Aya Spira; Stav Cohen; Elad Feldman; Ron Bitton; Avishai Wool; Ben Nassi,2026-07-08,2026,arXiv,arXiv,,Website: https://sites.google.com/view/agentic-botnets/home,cs.CR,arxiv-api,,,,,,,,,2607.07433,,2026-07-18T08:16:45+00:00
ale-0340,GitLost: How We Tricked GitHub's AI Agent into Leaking Private Repos,https://noma.security/blog/gitlost-how-we-tricked-githubs-ai-agent-into-leaking-private-repos/,external,noma.security,ok,200,https://noma.security/blog/gitlost-how-we-tricked-githubs-ai-agent-into-leaking-private-repos/,https://noma.security/blog/gitlost-how-we-tricked-githubs-ai-agent-into-leaking-private-repos/,text/html; charset=UTF-8,GitLost: How We Tricked GitHub’s AI Agent into Leaking Private Repos - Noma Security,"TL;DR: Noma Labs discovered a critical prompt injection vulnerability within GitHub’s new Agentic Workflows, allowing an unauthenticated attacker to silently pull data from private repositories by posting a crafted GitHub Issue in a public repository belonging to the same organization as the private repositories. Noma Labs named the vulnerability GitLost. Introduction GitHub recently launched […]",,,,,noma.security,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0341,ScopeJudge: Cost-Aware Pre-Execution Gating for Offensive Security Agents,https://arxiv.org/abs/2607.07774,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07774,https://arxiv.org/abs/2607.07774,text/html; charset=utf-8,[2607.07774] ScopeJudge: Cost-Aware Pre-Execution Gating for Offensive Security Agents,"As LLM agents take on offensive security work, a single out-of-scope tool call can breach a client's engagement boundary, disrupt production, or void a bug-bounty finding. Unlike a fixed safety policy, the boundary that matters is declared in the user's request and must be inferred from intent. That challenge is sharpened by the adversarial nature of offensive security: the same tool call is in or out of scope depending not on the action itself but on the target it touches and the context in which it runs, which no fixed policy can enumerate in advance. We study pre-execution gating: a cheap, trusted LLM judge inspects each call proposed by a strong, swappable agent, and accepts or rejects it before it runs. We introduce ScopeJudge, a benchmark of 4,897 tool calls (7.7% scope violations) from agent trajectories on tasks engineered to tempt agents out of scope and labeled at the call level by professional penetration testers, with substantial inter-grader agreement (Fleiss kappa = 0.64) that sets an expert agreement reference point of F1 = 0.78. We evaluate eight judge models under five transcript strategies, varying how much context the judge sees, from the static policy alone to the full raw transcript, and chart the resulting cost-accuracy Pareto frontier. We find that a static policy is structurally insufficient for scope enforcement: blind to the user's request, judge recall collapses to near zero, confirming that scope lives in the request and that request-conditioned monitoring is necessary. Because a missed violation costs more than a spurious rejection, we report precision, recall, and F1 separately and recommend two operating points: a cost-sensitive configuration and a recall-first one for high-stakes deployments. We release the ScopeJudge dataset to support real-time monitoring and scalable oversight of autonomous security agents.",Shane Caldwell; Max Harley; Ads Dawson; Michael Kouremetis; Vincent Abruzzo; Will Pearce,2026-07-08,2026,arXiv,arXiv,,"22 pages, 4 figures, 4 tables",cs.CR,arxiv-api,,,,,,,,,2607.07774,,2026-07-18T08:16:45+00:00
ale-0342,Multi-Agent AI Control: Distributed Attacks Hamper Per-Instance Monitors,https://arxiv.org/abs/2607.07368,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07368,https://arxiv.org/abs/2607.07368,text/html; charset=utf-8,[2607.07368] Multi-Agent AI Control: Distributed Attacks Hamper Per-Instance Monitors,"AI control is a family of techniques to prevent an AI with malicious goals from subverting its operator's intent. AI Control usually studies a single agent in one trajectory, but real deployments run many agents over shared infrastructure, and the most severe risks (model-weight exfiltration, training-run poisoning) plausibly need several agents acting in concert. We initiate the empirical study of multi-agent AI control, formalising distributed attacks in which several agents jointly aim for a malicious goal. We develop FakeLab: a synthetic AI-lab codebase (9 services, 86 benign tasks, 4 attack objectives). We evaluate single agent monitoring against distributed attacks, varying the number of agents, their coordination, model capabilities and precise monitoring configuration. Our central finding is the fragmentation effect: as more agents coordinate to attack, per-agent monitoring becomes less likely to catch any of the attackers. Secondly, this is not driven by the ratio of benign to malicious code -- we argue this is likely dependent on model capability. Third, an explicit planner amplifies the fragmentation effect, raises the rate of completing the attack up to sevenfold, and mildly sharpens executors' poor monitor-theory-of-mind. Finally: a weak ""trusted"" monitor misses most attacks, while a stronger one cuts undetected success by more than an order of magnitude but remains imperfect. We are happy to share FakeLab, our control setting, with safety researchers on request.",Oliver Makins; Orazio Angelini; Zohreh Shams; Mary Phuong,2026-07-08,2026,arXiv,arXiv,,Submitted to NeurIPS; 81 pages; 32 figures and 24 tables,cs.LG,arxiv-api,,,,,,,,,2607.07368,,2026-07-18T08:16:45+00:00
ale-0343,Mitigating Taint-Style Vulnerabilities in MCP Servers via Security-Aware Tool Descriptions,https://arxiv.org/abs/2607.07461,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07461,https://arxiv.org/abs/2607.07461,text/html; charset=utf-8,[2607.07461] Mitigating Taint-Style Vulnerabilities in MCP Servers via Security-Aware Tool Descriptions,"Large language models (LLMs) are increasingly deployed as autonomous agents that interact with external tools and services via the Model Context Protocol (MCP), a standardized interface for dynamic tool invocation. While MCP simplifies integration, it also expands the attack surface and enables generic exploits across multiple servers. Despite prior work on malicious MCP servers, the vulnerability landscape of MCP servers remains underexplored. In this work, we systematically analyze MCP server vulnerabilities, focusing on metadata characteristics, vulnerable code patterns, and community responses. Our study reveals that taint-style vulnerabilities constitute a substantial fraction of MCP server vulnerabilities, require significant code modifications to remediate, and are met with slow community responses. Motivated by these findings, we propose SPELLSMITH, presenting a novel textbased avenue for shielding taint-style vulnerabilities in MCP servers. In particular, SPELLSMITH analyzes the high-risk capabilities exposed by an MCP server and combines them with tool descriptions and parameter semantics to identify potential taint-style vulnerability risks, thereby constructing a tool-level risk profile. Then, SPELLSMITH leverages the Description property of the protocol to embed behavioral guidance (Description Enhancement Module) and exploits LLMs' self-reflection capabilities (Self-Reflection Module) to iteratively evaluate and refine outputs. By strengthening LLM internal decision-making, SPELLSMITH provides an active and unified mitigation strategy that generalizes across multiple vulnerabilities, reducing reliance on context-specific code-level fixes. Our experiments demonstrate that SPELLSMITH effectively mitigates taint-style vulnerability exploitation in MCP servers, highlighting its practical applicability and advantages over traditional code-level mitigations.",Yang Shi; Jiaheng Fu; Yihe Huang; Ruixiang Wu; Chengyao Sun; Kaifeng Huang,2026-07-08,2026,arXiv,arXiv,,,cs.CR,arxiv-api,,,,,,,,,2607.07461,,2026-07-18T08:16:45+00:00
ale-0344,Factory Droid Shield 2.0: Learned Secret Detection for Autonomous Commits,https://factory.ai/news/droid-shield-2-0,external,factory.ai,ok,200,https://factory.ai/news/droid-shield-2-0,https://factory.ai/news/droid-shield-2-0,text/html; charset=utf-8,Droid Shield 2.0: learned secret detection | Factory.ai Factory.ai Logo Arrow Right Icon,"Droid Shield 2.0: learned secret detection Factory's Droids write, refactor, and commit code autonomously at a volume th...",Factory,2026-07-01,2026,,Factory,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0345,destructive_command_guard,https://github.com/Dicklesworthstone/destructive_command_guard,external,github.com,ok,200,https://github.com/Dicklesworthstone/destructive_command_guard,https://github.com/Dicklesworthstone/destructive_command_guard,text/html; charset=utf-8,GitHub - Dicklesworthstone/destructive_command_guard: The Destructive Command Guard (dcg) is for blocking dangerous git and shell commands from being executed by agents. · GitHub,The Destructive Command Guard (dcg) is for blocking dangerous git and shell commands from being executed by agents. - Dicklesworthstone/destructive_command_guard,,2026-01-07,2026,Dicklesworthstone/destructive_command_guard,GitHub,,,,github-api,Dicklesworthstone/destructive_command_guard,5086,192,11,The Destructive Command Guard (dcg) is for blocking dangerous git and shell commands from being executed by agents.,NOASSERTION,2026-01-07T22:27:34Z,2026-07-18T07:31:38Z,,,2026-07-18T08:16:45+00:00
ale-0346,Friendly Fire: Hijacking Defensive Cyber AI Agents for Remote Code Execution,https://ainowinstitute.org/publications/friendly-fire-exploit-brief,external,ainowinstitute.org,ok,200,https://ainowinstitute.org/publications/friendly-fire-exploit-brief,https://ainowinstitute.org/publications/friendly-fire-exploit-brief,text/html; charset=UTF-8,Friendly Fire: Hijacking Defensive Cyber AI Agents for Remote Code Execution - AI Now Institute,"AI Now’s latest research demonstrates a critical attack vector on popular AI agents, built by Anthropic and OpenAI, when used for defensive purposes that actually turn the agent against its user.",Boyan Milanov,2026-07-08,2026,,AI Now Institute,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0347,How We Contain Claude Across Products,https://www.anthropic.com/engineering/how-we-contain-claude,external,www.anthropic.com,ok,200,https://www.anthropic.com/engineering/how-we-contain-claude,https://www.anthropic.com/engineering/how-we-contain-claude,text/html; charset=utf-8,How we contain Claude across products \ Anthropic,"Anthropic is an AI safety and research company that's working to build reliable, interpretable, and steerable AI systems.",,,,,Anthropic,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0348,Rethinking MCP Security: A Large-Scale Study of Runtime MCP Servers and Scanner Reliability,https://arxiv.org/abs/2607.11086,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.11086,https://arxiv.org/abs/2607.11086,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0349,Agent Hacks Agent: Autoresearch for Production-Agent Red-Teaming,https://arxiv.org/abs/2607.11698,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.11698,https://arxiv.org/abs/2607.11698,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0350,"Temporary Authority, Permanent Effects: Commit-Time Authorization for LLM Agents",https://arxiv.org/abs/2607.10487,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.10487,https://arxiv.org/abs/2607.10487,text/html; charset=utf-8,"[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-18T08:16:45+00:00
ale-0351,ANCHOR: Automated Alignment Auditing for CLI Agents on Real-World Harm,https://arxiv.org/abs/2607.10455,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.10455,https://openreview.net/forum?id=YqTodSrPPB,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0352,Clawk,https://github.com/clawkwork/clawk,external,github.com,ok,200,https://github.com/clawkwork/clawk,https://github.com/clawkwork/clawk,text/html; charset=utf-8,"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,700,20,3,"Give coding agents a disposable Linux VM, not your laptop",Apache-2.0,2026-07-06T21:30:38Z,2026-07-18T07:31:19Z,,,2026-07-18T08:16:45+00:00
ale-0353,Auto-Review of Agent Actions Without Synchronous Human Oversight,https://alignment.openai.com/auto-review/,external,alignment.openai.com,ok,200,https://alignment.openai.com/auto-review/,https://alignment.openai.com/auto-review/,text/html; charset=utf-8,"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-18T08:16:45+00:00
ale-0354,SAFETY SENTRY: Context-Aware Human Intervention via EXECUTE-ASK-REFUSE Routing,https://arxiv.org/abs/2607.13594,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.13594,https://arxiv.org/abs/2607.13594,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0355,CAVA: Canonical Action Verification and Attestation for Runtime Governance of Agentic AI Systems,https://arxiv.org/abs/2607.13716,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.13716,https://arxiv.org/abs/2607.13716,text/html; charset=utf-8,[2607.13716] CAVA: Canonical Action Verification and Attestation for Runtime Governance of Agentic AI Systems,"Agentic AI systems increasingly act through heterogeneous runtimes: local coding hooks, SDK tools, browser automation, managed-agent traces, API gateways, and workflow engines. A single operational act such as publishing code, changing identity state, moving money, or exporting data may therefore be represented by many incompatible runtime records. This makes a basic governance question difficult to answer: what action was actually approved, what evidence binds the approval to execution, and can an independent verifier reproduce the same action identity later? This paper presents Canonical Action Verification and Attestation (CAVA), a runtime-semantics layer for converting heterogeneous agent activity into canonical runtime action objects. CAVA is positioned below Proof-Carrying Agent Actions (PCAA): PCAA defines the deployer-owned route-review-prove governance process, while CAVA defines the stable action object that process governs. The paper formalizes canonical action identity, semantic pattern detection, approval binding, receipt integrity, runtime-portable projection, and optional attestation substrates. We study a reference implementation through a 96-seed, 384-variant benchmark covering semantic equivalence, semantic separation, wrapper bypass, false-positive control, approval binding, receipt reproducibility, attestation tamper detection, runtime portability, semantic pattern detection, policy degradation, and Azure deployment drills. The contribution is a systems formulation of action-level canonicalization and policy-addressable semantic patterns as a necessary substrate for deployer-side AI governance.",Zexun Wang,2026-07-15,2026,arXiv,arXiv,,"35 pages. Working paper on canonical action verification, runtime governance, semantic pattern detection, and approval-bound action receipts",cs.AI,arxiv-api,,,,,,,,,2607.13716,,2026-07-18T08:16:45+00:00
ale-0356,"How Agents Ask for Permission: User Permissions for AI Agents, from Interfaces to Enforcement",https://arxiv.org/abs/2607.13718,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.13718,https://arxiv.org/abs/2607.13718,text/html; charset=utf-8,"[2607.13718] How Agents Ask for Permission: User Permissions for AI Agents, from Interfaces to Enforcement","As AI agents gain prevalance, users are increasingly exposed to the risks such systems entail. Prompt injection attacks, as well as hallucination, can cause agents to leak private information to third parties. As autonomous systems, agents also present the more active danger of performing sensitive tasks, such as bank transactions, without the user's intent or authorization. Recognizing this challenge, the agentic security community has developed numerous proposals for secure agentic systems. Much of this work has focused on product-level approaches, where agentic system developers determine and apply the same security policies and permissions to all users. Yet different users have different needs and preferences, necessitating support for user-level permissions policies in agentic AI systems. To understand how user-level permissions are handled in AI agent systems, we survey 21 proposals for agent permissions systems. From this review, we construct a taxonomy of how different systems specify user-level permissions policies, both at the user interface and internally; derive internal policies from user input; and enforce those policies at run-time. We then analyze five prominent commercial agents and compare their permissions handling to agentic permissions systems in the literature. We identify several high-level themes across the literature and commerical agents, as well as multiple gaps where future work is needed.",Alexandra E. Michael; Franziska Roesner,2026-07-15,2026,arXiv,arXiv,,"15 pages, 4 figures",cs.CR,arxiv-api,,,,,,,,,2607.13718,,2026-07-18T08:16:45+00:00
ale-0357,Stop Means Stop: Measuring and Repairing the Enforcement Gap in Agent-Framework Control Primitives,https://arxiv.org/abs/2607.14166,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14166,https://arxiv.org/abs/2607.14166,text/html; charset=utf-8,[2607.14166] Stop Means Stop: Measuring and Repairing the Enforcement Gap in Agent-Framework Control Primitives,"Production LLM-agent frameworks expose control primitives -- human-in-the-loop approval gates, run cancellation, and execution timeouts -- whose names and documentation imply barrier semantics: while a run is paused, cancelled, or timed out, no gated side effect executes. We show this implied contract holds on none of the six widely used open-source frameworks we test. Model-free differential probes isolate a recurring sibling leak -- an approval gate suspends its own branch while a sibling branch's effect executes during the pause, so a later rejection cannot prevent it -- in every framework shipping a pre-execution gate (five of six), plus three further gaps: replay double-execution, cancellation orphans, and timeout zombies. The hazard is reachable, not merely constructible: under an a-priori-fixed protocol, frontier models emit the leak-triggering plan shape at pooled rates up to 14%, and when live models drive the unmodified frameworks under an approval pause, 215 of 1,200 runs execute their effect during the pause, across three schedulers and two language runtimes. To repair the measured gaps we present SOUNDGATE, an environment-external effect gate in Rust through which every side effect must be admitted, enforcing hold-until-decided, reject-cancels, dedup-on-replay, and fence-on-cancel -- one property per violation class -- under a stated complete-mediation contract discharged for network egress by kernel-enforced routes. We verify the properties over a model of the admission core (Verus; TLA+/TLC, exhaustive to 7.5e7 states; TLAPS), model-check the deployed Rust with Loom, and bridge model to code by differential conformance over 1.2e7 operations -- refinement evidence, not a mechanized proof. SOUNDGATE blocks every measured violation end-to-end on all six frameworks while releasing legitimate effects, at about 1 ms admission per write and 12k-26k durable admissions per second.",Sajjad Khan,2026-07-15,2026,arXiv,arXiv,,"31 pages, 3 figures, 11 tables",cs.SE,arxiv-api,,,,,,,,,2607.14166,,2026-07-18T08:16:45+00:00
ale-0358,Bad Memory: Evaluating Prompt Injection Risks from Memory in Agentic Systems,https://arxiv.org/abs/2607.14611,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14611,https://arxiv.org/abs/2607.14611,text/html; charset=utf-8,[2607.14611] Bad Memory: Evaluating Prompt Injection Risks from Memory in Agentic Systems,"A growing class of agentic systems maintain persistent state across sessions through memory files, behavioral preferences, and knowledge bases. While this makes agents more useful and self-improving, it also creates a new attack surface for prompt injections in which malicious instructions can be embedded within persistent files and influence future behavior. In this work, we study prompt injection attacks in memory-based agentic systems using a sandboxed synthetic workspace. We evaluate two agentic systems, Anthropic Claude Code and OpenAI Codex, across four models: Claude Haiku 4.5, Claude Opus 4.7, GPT-5.2, and GPT-5.5. Our results show that although it is difficult to make an agent overwrite its own memory files using untrusted external content, payloads already planted in those files can successfully attack current and future sessions. Attack success and payload persistence vary substantially across systems, models, adversarial goals, and multi-session attack sequences. These findings show that persistent memory changes the threat model for prompt injection and motivate defenses that protect memory updates without removing useful agent adaptation.",Soham Gadgil; David Alexander; Sai Sunku; Franziska Roesner,2026-07-16,2026,arXiv,arXiv,,Preprint,cs.CR,arxiv-api,,,,,,,,,2607.14611,,2026-07-18T08:16:45+00:00
ale-0359,"Setup Complete, Now You Are Compromised: Weaponizing Setup Instructions Against AI Coding Agents",https://arxiv.org/abs/2607.15143,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.15143,https://arxiv.org/abs/2607.15143,text/html; charset=utf-8,"[2607.15143] Setup Complete, Now You Are Compromised: Weaponizing Setup Instructions Against AI Coding Agents","AI coding agents set up projects by reading documentation and installing the dependencies it lists, without verifying their names, sources, or known vulnerabilities. By editing only a README, requirements file, or Makefile, an attacker can redirect the agent to an untrusted registry, a known-vulnerable version, or a wrong-but-plausible name: documentation becomes a vector for code execution. We present the first systematic evaluation of package-install-time supply-chain attacks delivered through ordinary project-setup documentation across production coding-agent harnesses, probing frontier models on twelve scenarios in five attack classes, grounded in documented incidents. The same model catches an attack through one harness and installs it through another: install-time security rests on the harness-model combination, not the model alone. Agents catch blatant typosquats reliably, but plausible separator-confusion names (azurecore for azure-core) slip through, and how often depends on the harness-model pairing. Source-based attacks like registry redirection are missed almost everywhere. The source blind spot recurs on npm and Cargo, where nearly every model installs the untrusted dependency; name detection carries over less consistently across ecosystems. Security-oriented prompts recover part of the gap but only for the dimension they name; a deterministic pre-install check that verifies names, sources, and versions before any code runs closes most of it.",Aadesh Bagmar; Pushkar Saraf,2026-07-16,2026,arXiv,arXiv,,,cs.CR,arxiv-api,,,,,,,,,2607.15143,,2026-07-18T08:16:45+00:00
ale-0360,OS-Sentinel: Towards Safety-Enhanced Mobile GUI Agents via Hybrid Validation in Realistic Workflows,https://aclanthology.org/2026.acl-long.431/,external,aclanthology.org,ok,200,https://aclanthology.org/2026.acl-long.431/,https://aclanthology.org/2026.acl-long.431/,text/html; charset=utf-8,OS-Sentinel: Towards Safety-Enhanced Mobile GUI Agents via Hybrid Validation in Realistic Workflows - ACL Anthology,"Qiushi Sun, Mukai Li, Zhoumianze Liu, Zhihui Xie, Fangzhi Xu, Zhangyue Yin, Kanzhi Cheng, Zehao Li, Zichen Ding, Qi Liu, Zhiyong Wu, Zhuosheng Zhang, Ben Kao, Lingpeng Kong. Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 2026.",Qiushi Sun; Mukai Li; Zhoumianze Liu; Zhihui Xie; Fangzhi Xu; Zhangyue Yin; Kanzhi Cheng; Zehao Li; Zichen Ding; Qi Liu; Zhiyong Wu; Zhuosheng Zhang; Ben Kao; Lingpeng Kong,2026,2026,Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers),ACL Anthology,10.18653/v1/2026.acl-long.431,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0361,Effective Context Engineering for AI Agents,https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents,external,www.anthropic.com,ok,200,https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents,https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents,text/html; charset=utf-8,Effective context engineering for AI agents \ Anthropic,"Anthropic is an AI safety and research company that's working to build reliable, interpretable, and steerable AI systems.",,,,,Anthropic,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0362,Agent Harnesses: the Infrastructure Layer Your LLM Agent Actually Needs,https://ninadpathak.com/blog/agent-harnesses/,external,ninadpathak.com,ok,200,https://ninadpathak.com/blog/agent-harnesses/,https://ninadpathak.com/blog/agent-harnesses/,text/html; charset=utf-8,Agent Harnesses: the Infrastructure Layer Your Llm Agent Actually Needs | Ninad Pathak,"Every production AI agent needs a harness. Here is what one contains, why frameworks often are not enough, and how to build the layer that actually determines reliability.",,,,,ninadpathak.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0363,The Agent Loop Is the New OS,https://www.harness.io/blog/agent-loop-new-os,external,www.harness.io,ok,200,https://www.harness.io/blog/agent-loop-new-os,https://www.harness.io/blog/agent-loop-new-os,text/html; charset=utf-8,The Agent Loop Is the New OS | Harness Blog | Harness Share in X Share in Facebook Share in LinkedIn Search in ChatGpt Github icon LinkedIn icon Facebook icon Instagram icon Twitter icon,"The Harness MCP server treats the AI agent loop as an operating system, mapping the LLM to the CPU and the Context Window to RAM. Learn how this design uses 10 generic, composable tools to abstract complexity and keep the context window clean for higher-quality, cost-efficient AI agent reasoning. | Blog",,2026,2026,,Harness.io,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0364,Harness engineering for coding agent users,https://martinfowler.com/articles/harness-engineering.html,external,martinfowler.com,ok,200,https://martinfowler.com/articles/harness-engineering.html,https://martinfowler.com/articles/harness-engineering.html,text/html,Harness engineering for coding agent users,"A mental model for building trust in coding agents through feedforward guides, feedback sensors, and iterative harness engineering.",,,,,martinfowler.com,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0365,Context Engineering,https://simonwillison.net/2025/Jun/27/context-engineering/,external,simonwillison.net,ok,200,https://simonwillison.net/2025/Jun/27/context-engineering/,https://simonwillison.net/2025/Jun/27/context-engineering/,text/html; charset=utf-8,Context engineering,The term context engineering has recently started to gain traction as a better alternative to prompt engineering. I like it. I think this one may have sticking power. Here's an …,Simon Willison,,2025,,Simon Willison’s Weblog,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0366,Agentic Coding in 2026,https://sourcegraph.com/blog/agentic-coding,external,sourcegraph.com,ok,200,https://sourcegraph.com/blog/agentic-coding,https://sourcegraph.com/blog/agentic-coding,text/html,Agentic Coding in 2026: A Practical Guide for Big Code | Sourcegraph,"Learn what agentic coding is, how AI coding agents work in real engineering orgs, and how to give them the codebase context they need to ship safely.",,,,,Sourcegraph,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0367,Agentic AI State Management with ScyllaDB and LangGraph,https://www.scylladb.com/2026/04/08/agentic-ai-state-management-with-scylladb-and-langgraph/,external,www.scylladb.com,ok,200,https://www.scylladb.com/2026/04/08/agentic-ai-state-management-with-scylladb-and-langgraph/,https://www.scylladb.com/2026/04/08/agentic-ai-state-management-with-scylladb-and-langgraph/,text/html; charset=UTF-8,Agentic AI State Management with ScyllaDB and LangGraph | ScyllaDB,"How to combine LangGraph and ScyllaDB for durable state management, crash recovery, and a highly available backend for your agentic AI applications.",Cynthia Dunlop,2026-04-08,2026,,ScyllaDB,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0368,Mem0,https://github.com/mem0ai/mem0,external,github.com,ok,200,https://github.com/mem0ai/mem0,https://github.com/mem0ai/mem0,text/html; charset=utf-8,GitHub - mem0ai/mem0: Universal memory layer for AI Agents · GitHub,Universal memory layer for AI Agents. Contribute to mem0ai/mem0 development by creating an account on GitHub.,,2023-06-20,2023,mem0ai/mem0,GitHub,,,,github-api,mem0ai/mem0,61092,7110,628,Universal memory layer for AI Agents,Apache-2.0,2023-06-20T08:58:36Z,2026-07-18T08:05:33Z,,,2026-07-18T08:16:45+00:00
ale-0369,Letta,https://github.com/letta-ai/letta,external,github.com,ok,200,https://github.com/letta-ai/letta,https://github.com/letta-ai/letta,text/html; charset=utf-8,GitHub - letta-ai/letta: Platform for stateful agents: AI with advanced memory that can learn and self-improve over time. · GitHub,Platform for stateful agents: AI with advanced memory that can learn and self-improve over time. - letta-ai/letta,,2023-10-11,2023,letta-ai/letta,GitHub,,,,github-api,letta-ai/letta,23838,2532,48,Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.,Apache-2.0,2023-10-11T07:38:37Z,2026-07-18T07:44:31Z,,,2026-07-18T08:16:45+00:00
ale-0370,Zep,https://github.com/getzep/zep,external,github.com,ok,200,https://github.com/getzep/zep,https://github.com/getzep/zep,text/html; charset=utf-8,"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,4764,641,17,"Zep | Examples, Integrations, & More",Apache-2.0,2023-04-29T14:06:22Z,2026-07-18T04:40:13Z,,,2026-07-18T08:16:45+00:00
ale-0371,LangMem,https://github.com/langchain-ai/langmem,external,github.com,ok,200,https://github.com/langchain-ai/langmem,https://github.com/langchain-ai/langmem,text/html; charset=utf-8,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,56,,MIT,2025-01-21T20:06:59Z,2026-07-17T07:50:42Z,,,2026-07-18T08:16:45+00:00
ale-0372,Beads,https://github.com/steveyegge/beads,external,github.com,ok,200,https://github.com/gastownhall/beads,https://github.com/gastownhall/beads,text/html; charset=utf-8,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,25405,1705,506,Beads - A memory upgrade for your coding agent,MIT,2025-10-12T03:09:46Z,2026-07-18T06:09:19Z,,,2026-07-18T08:16:45+00:00
ale-0373,ARC: Active and Reflection-driven Context Management for Long-Horizon Agents,https://arxiv.org/abs/2601.12030,external,arxiv.org,ok,200,https://arxiv.org/abs/2601.12030,https://aclanthology.org/2026.findings-acl.930/,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0374,"Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers",https://arxiv.org/abs/2603.07670,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.07670,https://arxiv.org/abs/2603.07670,text/html; charset=utf-8,"[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-18T08:16:45+00:00
ale-0375,"Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering",https://arxiv.org/abs/2604.08224,external,arxiv.org,ok,200,https://arxiv.org/abs/2604.08224,https://arxiv.org/abs/2604.08224,text/html; charset=utf-8,"[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-18T08:16:45+00:00
ale-0376,Meta Context Engineering via Agentic Skill Evolution,https://arxiv.org/abs/2601.21557,external,arxiv.org,ok,200,https://arxiv.org/abs/2601.21557,https://arxiv.org/abs/2601.21557,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0377,Are We Ready for an Agent-Native Memory System?,https://arxiv.org/abs/2606.24775,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.24775,https://arxiv.org/abs/2606.24775,text/html; charset=utf-8,[2606.24775] Are We Ready For An Agent-Native Memory System?,"Memory for large language model (LLM) agents has rapidly evolved from simple retrieval-augmented mechanisms into a data management system that supports persistent information storage, retrieval, update, consolidation, and dynamic lifecycle governance throughout agent execution. Despite this evolution, existing evaluations still benchmark agent memory mainly through end-to-end task success metrics (e.g., F1, BLEU), while treating the underlying system as a monolithic black box. As a result, critical system-level concerns, including operational costs, architectural trade-offs across memory modules, and robustness under dynamic knowledge updates, remain insufficiently explored. In this paper, we present a systematic experimental study of agent memory from a data management perspective. We propose an analytical framework that decomposes agent memory into four core modules: memory representation and storage, extraction, retrieval and routing, and maintenance. Under this framework, we evaluate 12 representative memory systems and two reference baselines across five benchmark workloads spanning 11 datasets. Our extensive end-to-end evaluation shows that no single architecture dominates across all scenarios; instead, effectiveness depends heavily on how well the memory structure aligns with the workload bottleneck. Furthermore, through fine-grained ablation studies, we quantify their individual effects on representation fidelity, retrieval precision, update correctness, and long-horizon stability. Finally, we reveal cost-performance trade-offs under realistic workloads, showing localized maintenance is more cost-efficient than global reorganization. Based on these findings, we identify promising directions towards building truly agent-native memory systems. The code is publicly available at https://github.com/OpenDataBox/MemoryData.",Wei Zhou; Xuanhe Zhou; Shaokun Han; Hongming Xu; Guoliang Li; Zhiyu Li; Feiyu Xiong; Fan Wu,2026-06-23,2026,arXiv,arXiv,,Paper list available at: https://github.com/OpenDataBox/awesome-agent-memory. Source code available at: https://github.com/OpenDataBox/MemoryData,cs.CL,arxiv-api,,,,,,,,,2606.24775,,2026-07-18T08:16:45+00:00
ale-0378,Self-Evolving World Models for LLM Agent Planning,https://arxiv.org/abs/2606.30639,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.30639,https://arxiv.org/abs/2606.30639,text/html; charset=utf-8,[2606.30639] Self-Evolving World Models for LLM Agent Planning,"World models offer a principled way to equip long-horizon LLM agents with foresight: predictions of action consequences before execution. However, unreliable foresight can be ignored, misused, or even degrade downstream decision-making. In this paper, we introduce WorldEvolver, a self-evolving world model framework that revises its deployment-time context while keeping the downstream agent and all model parameters frozen. WorldEvolver integrates three modules: (i) Episodic Memory, which exploits real action transitions through retrieval-based simulation; (ii) Semantic Memory, which extracts persistent heuristic rules from prediction-observation mismatches; and (iii) Selective Foresight, which filters low-confidence predictions before integrating them into agent reasoning context. We evaluate WorldEvolver on ALFWorld and ScienceWorld, measuring world model prediction accuracy on Word2World and downstream agent success rate on AgentBoard. Extensive experiments show that WorldEvolver achieves the highest prediction accuracy across three backbones and leads other world model baselines on downstream agent success rate, demonstrating that test-time memory revision enhances both predictive fidelity and planning performance.",Xuan Zhang; Wenxuan Zhang; See-Kiong Ng; Yang Deng,2026-06-29,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2606.30639,,2026-07-18T08:16:45+00:00
ale-0379,Rethinking Continual Experience Internalization for Self-Evolving LLM Agents,https://arxiv.org/abs/2606.04703,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.04703,https://arxiv.org/abs/2606.04703,text/html; charset=utf-8,[2606.04703] Rethinking Continual Experience Internalization for Self-Evolving LLM Agents,"Experience internalization converts contextual experience from past interactions into reusable parametric capability, offering a promising path toward continual learning in large language models (LLMs). While prior work has predominantly focused on single-iteration transfer, we discover that under multi-iteration experience learning, existing methods suffer from a progressive capability collapse rather than compounding improvement. We systematically examine this failure through three vital dimensions of experience internalization: (1) Experience Granularity: We find that principle-level experience is more durable than instance-level experience, as it effectively abstracts transferable strategies away from trajectory-specific details. (2) Experience Injection Pattern: Our analysis reveals that step-wise injection significantly outperforms global injection by aligning experience with intermediate decision states, a property that is critical for long-horizon tool use. (3) Internalization Regime: We demonstrate that off-policy context-distillation on high-quality teacher trajectories provides a substantially more stable training signal than on-policy context-distillation, which is inherently limited by local corrections on student-induced flawed states. Together, these insights yield a simple yet robust recipe for stable and sustainable experience internalization, providing concrete guidance for engineering self-evolving and continually learning LLMs.",Jingwen Chen; Wenkai Yang; Shengda Fan; Wenbo Nie; Chenxing Sun; Shaodong Zheng; Yangen Hu; Lu Pan; Ke Zeng; Yankai Lin,2026-06-03,2026,arXiv,arXiv,,"10 pages, 8 figures",cs.CL,arxiv-api,,,,,,,,,2606.04703,,2026-07-18T08:16:45+00:00
ale-0380,GenericAgent,https://github.com/lsdefine/GenericAgent,external,github.com,ok,200,https://github.com/lsdefine/GenericAgent,https://github.com/lsdefine/GenericAgent,text/html; charset=utf-8,"GitHub - lsdefine/GenericAgent: Self-evolving agent: grows skill tree from 3.3K-line seed, achieving full system control with 6x less token consumption · GitHub","Self-evolving agent: grows skill tree from 3.3K-line seed, achieving full system control with 6x less token consumption - lsdefine/GenericAgent",,2026-01-16,2026,lsdefine/GenericAgent,GitHub,,,,github-api,lsdefine/GenericAgent,13473,1559,170,"Self-evolving agent: grows skill tree from 3.3K-line seed, achieving full system control with 6x less token consumption",MIT,2026-01-16T15:45:24Z,2026-07-18T08:05:30Z,,,2026-07-18T08:16:45+00:00
ale-0381,Self-GC: Self-Governing Context for Long-Horizon LLM Agents,https://arxiv.org/abs/2607.00692,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.00692,https://arxiv.org/abs/2607.00692,text/html; charset=utf-8,[2607.00692] Self-GC: Self-Governing Context for Long-Horizon LLM Agents,"Long-horizon LLM agents accumulate tool results, files, plans, and user constraints that are too structured to be treated as a disposable text suffix. Current systems mostly rely on in-run heuristics such as chronological pruning and tool-output masking, or on final self-summary near a context limit. Heuristics are cheap but blind to future dependencies; summaries preserve narrative state but often hide exact evidence, locators, and editable artifacts. We present Self-GC, where GC denotes self-governing context while deliberately echoing garbage collection: the system does not merely reclaim unused tokens, but governs the lifecycle of agent context objects. Self-GC turns user turns, tool spans, and skill state into indexed objects; asks a side-channel planner to propose fold, mask, and prune actions; and lets the harness enforce recoverable sidecars, safe commit boundaries, and cache-aware commit. On a 33-session Hard Set, Self-GC prunes 43.95% of prefix tokens while leaving 84.85% of future continuations unaffected, compared with no-impact rates of 54.55% to 69.70% for heuristic baselines. On a 332-session production-derived suite, three planner backbones reach no-impact rates of 91.27% to 94.58%, while baselines remain at 77.71% to 87.46%. In production, an online account-level split reduces daytime average input tokens by 10% to 15%, with peak reductions near 20%. These results point to context management as runtime lifecycle control over indexed, recoverable objects rather than post hoc text cleanup.",Xubin Hao; Hongjin Meng; Xin Yin; Jiawei Zhu; Chenpeng Cao,2026-07-01,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.00692,,2026-07-18T08:16:45+00:00
ale-0382,CompactionRL: Reinforcement Learning with Context Compaction for Long-Horizon Agents,https://arxiv.org/abs/2607.05378,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.05378,https://arxiv.org/abs/2607.05378,text/html; charset=utf-8,[2607.05378] CompactionRL: Reinforcement Learning with Context Compaction for Long-Horizon Agents,"Long-horizon agentic LLMs are increasingly limited by finite context windows, as extended interaction trajectories can exceed the maximum context length before a task is completed. Context compaction offers a natural solution by summarizing previous interaction states and continuing the rollout under a compressed context, but incorporating compaction into reinforcement learning remains underexplored. We propose CompactionRL, a reinforcement learning strategy to train long-horizon agentic LLMs with context compaction. Our approach jointly optimizes task execution and summary generation with token-level loss normalization and cross-trajectory generalized advantage estimation. This design enables the LLM agents to learn from compacted long-horizon trajectories. We train CompactionRL on top of open models and observe consistent performance gains on agentic coding tasks. CompactionRL enables the open GLM-4.5-Air model (106B-A30B) to achieve Pass@1 scores of 66.8% on SWE-bench Verified and 24.5% on Terminal-Bench 2.0, with absolute gains of 7.0 and 3.1 points, respectively. Built upon GLM-4.7-Flash (30B-A3B), CompactionRL improves Pass@1 by 5.5 and 6.8 points, reaching 56.0% on SWE-bench Verified and 20.2% on Terminal-Bench 2.0, respectively. CompactionRL is thus deployed in the RL pipeline for training the open GLM-5.2 model (750B-A40B).",Yujiang Li; Zhenyu Hou; Yi Jing; Jie Tang; Yuxiao Dong,2026-07-06,2026,arXiv,arXiv,,,cs.LG,arxiv-api,,,,,,,,,2607.05378,,2026-07-18T08:16:45+00:00
ale-0383,SelfMem: Self-Optimizing Memory for AI Agents,https://arxiv.org/abs/2607.03726,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.03726,https://arxiv.org/abs/2607.03726,text/html; charset=utf-8,[2607.03726] SelfMem: Self-Optimizing Memory for AI Agents,"While current AI agents support increasingly long context windows, tool use, and skill execution for long-horizon tasks, they still require memory systems to effectively leverage historical experience. Existing memory frameworks typically rely on fixed storage, retrieval, and summarization mechanisms, which can be rigid across different tasks and often require manual tuning. To address this limitation, we propose SelfMem, a self-optimizing memory framework. Inspired by prior work on self-improving AI, we follow the principle of ""teaching an agent to fish rather than giving it a fish."" Instead of forcing the model to follow a predefined memory strategy or format, SelfMem provides an environment with memory tools and feedback signals that allow the agent to explore, evaluate, and refine its own memory strategy. Our results show that SelfMem consistently outperforms retrieval, compression, and agent-memory baselines on BEAM across conversation scales from 100K to 1M tokens. Compared with the strongest baseline, SelfMem improves the official score by 48.7%, 40.8%, and 41.9% at 100K, 500K, and 1M, respectively. Further question-type analysis shows broad robustness across diverse memory demands, and our optimization study shows that model-guided strategy refinement further improves performance.",Shu Yang; Junchao Wu; Derek F. Wong; Di Wang,2026-07-04,2026,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,,,2607.03726,,2026-07-18T08:16:45+00:00
ale-0384,Memory-Orchestrated Semantic System (MOSS): An Auditable Agentic Memory Architecture,https://arxiv.org/abs/2607.04391,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.04391,https://arxiv.org/abs/2607.04391,text/html; charset=utf-8,[2607.04391] Memory-Orchestrated Semantic System (MOSS): An Auditable Agentic Memory Architecture,"Long-term memory remains a structural weakness of AI agents. The dominant approach, retrieval-augmented generation (RAG), relies on embedding-based similarity search, which is opaque by construction, difficult to audit, and bounded by the theoretical limits of vector representations. We present the Memory-Orchestrated Semantic System (MOSS), an agentic memory architecture in which the agent drives retrieval over a structured relational database. MOSS is model-agnostic, storage-agnostic, and API-agnostic: it runs on any relational engine, connects to any LLM provider (or to deterministic non-LLM processes), and deploys on any infrastructure, local or cloud. Its retrieval execution is symbolic and reproducible (once a query is formulated, no LLM participates in the retrieval loop) and every step of the system, from indexing to answer formulation, is logged and inspectable, making MOSS auditable by construction. Rather than imposing an external ontology, MOSS derives its conceptual vocabulary from the corpus itself. We report on a longitudinal deployment unique in the agentic-memory literature: a year of continuous production over an individual scholar's working corpus--a conversational corpus reaching back to October 2024 (some 44 million tokens, retroactively indexed) comprising 110,183 segments, alongside 163,494 catalogued documents, 569 inductively derived concepts, 322,662 concept annotations, and eleven metadata graphs totaling approximately five million relations--across four successive infrastructure generations. While the present case is that of a single researcher, the architecture is in no way specific to one person: it serves a team, an institution, or any entity that accumulates knowledge over time. We argue that auditable, sovereign, structurally unbounded memory is a precondition for AI agents intended to accompany a person or an organization over years rather than sessions.",Serge Lacasse; Jérémie Hatier; Alex Baker,2026-07-05,2026,arXiv,arXiv,,"22 pages, 2 figures",cs.CL,arxiv-api,,,,,,,,,2607.04391,,2026-07-18T08:16:45+00:00
ale-0385,"The Log Is the Agent: Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems",https://arxiv.org/abs/2605.21997,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.21997,https://arxiv.org/abs/2605.21997,text/html; charset=utf-8,"[2605.21997] The Log is the Agent: Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems","Most agent frameworks are built around the language model: a conversation loop comes first, then tools, then rules, and finally a logging layer bolted on for observability, with state persisted as retrievable ""memory."" We describe ActiveGraph, a runtime that inverts this arrangement. The append-only event log is the source of truth; the working graph is a deterministic projection of that log; and behaviors--ordinary functions, classes, LLM-backed routines, or logic attached to typed edges--react to changes in the graph and emit new events. No component instructs another; coordination happens entirely through the shared graph. This single design decision yields three properties that retrieval-and-summarization memory systems do not provide: deterministic replay of any run from its log, cheap forking that branches a run at any event without re-executing the shared prefix, and end-to-end lineage from a high-level goal down to the individual model call that produced each artifact. We present the architecture, a determinism contract that makes replay sound, and a worked diligence example whose full causal structure is reconstructable from the log alone. We discuss--without claiming to demonstrate--why this substrate is unusually well suited to self-improving agents, and how it extends the BabyAGI lineage and prior graph-memory research.",Yohei Nakajima,2026-05-21,2026,arXiv,arXiv,,"11 pages, 1 figure. Open-source Apache-2.0 implementation with reproducible quickstart demo, deterministic replay, fork-and-diff, and lineage tracing",cs.AI,arxiv-api,,,,,,,,,2605.21997,,2026-07-18T08:16:45+00:00
ale-0386,Agentics: Memorizing Session Transcripts Isn't Useful,https://12gramsofcarbon.com/p/agentics-memorizing-session-transcripts,external,12gramsofcarbon.com,ok,200,https://12gramsofcarbon.com/p/agentics-memorizing-session-transcripts,https://12gramsofcarbon.com/p/agentics-memorizing-session-transcripts,text/html; charset=utf-8,Agentics: Memorizing Session Transcripts Isn't Useful,"Keep track of artifacts, not scratch. Alt title: Claude, please stop trying to memorize random crap",theahura,,,,12gramsofcarbon.com,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0387,Long-Running Agents,https://addyo.substack.com/p/long-running-agents,external,addyo.substack.com,ok,200,https://addyo.substack.com/p/long-running-agents,https://addyo.substack.com/p/long-running-agents,text/html; charset=utf-8,Long-running Agents - by Addy Osmani - Elevate,"A long-running AI agent can keep making progress over hours, days, or weeks.",Addy Osmani,,,,Substack,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0388,StateFuse: Deterministic Conflict-Preserving Memory for Multi-Agent Systems,https://arxiv.org/abs/2607.05844,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.05844,https://arxiv.org/abs/2607.05844,text/html; charset=utf-8,[2607.05844] StateFuse: Deterministic Conflict-Preserving Memory for Multi-Agent Systems,"Agent systems accumulate conflicting observations across branches, retries, and replicas, yet many practical memory layers still collapse disagreement behind overwrite rules that are difficult to inspect or correct. We present StateFuse, a conflict-aware replicated memory contract built on standard OpSet/CRDT merge. StateFuse does not introduce a new join algebra; it defines an agent-facing semantics layer with immutable history, explicit conflict objects, exact and semantic correction handles (claim_id / claim_ref), deterministic predicate contracts, and projection-time resolution that cannot rewrite replicated state. We evaluate StateFuse against flat multi-value, raw-log, provenance-style, and collapsed baselines under matched resolver and verification policies. On a 282-question official conflict-bearing MemoryAgentBench slice, the compared methods tie on answer accuracy, but conflict-preserving surfaces keep contradictions visible while collapsed surfaces do not. In a controlled agent loop with uniform verification, preserving ambiguity enables safer abstention and correction than early collapse. A correction-handle ablation further shows that semantic handles matter when exact prior identifiers are unavailable. The resulting claim is narrow: StateFuse is best supported as a safer public memory contract for contradiction surfacing, abstention, and auditable correction, not as a universal accuracy gain.",Sergey Volkov; Yang Li; Ye Luo,2026-07-07,2026,arXiv,arXiv,,Code and supplementary materials available at: https://github.com/nZiben/statefuse,cs.AI,arxiv-api,,,,,,,,,2607.05844,,2026-07-18T08:16:45+00:00
ale-0389,Remember When It Matters: Proactive Memory Agent for Long-Horizon Agents,https://arxiv.org/abs/2607.08716,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08716,https://arxiv.org/abs/2607.08716,text/html; charset=utf-8,[2607.08716] Remember When It Matters: Proactive Memory Agent for Long-Horizon Agents,"In long-horizon tasks, decision-relevant state is often scattered across an expanding trajectory, while the action agent must surface it and act. As trajectories grow, task requirements, environment facts, prior attempts, diagnoses, and open subgoals can be buried in the context window or pushed beyond it, failing to influence decisions when needed. We call this failure mode ""behavioral state decay"". We study memory as an active intervention mechanism rather than passive retrieval. A separate memory agent runs alongside an unmodified action agent, updating a structured memory bank from the recent trajectory and deciding whether to inject a memory-grounded reminder or remain silent. The module is plug-and-play with frontier action agents and existing agent harnesses. Across Terminal-Bench 2.0 and $\tau^2$-Bench, it improves pass@1 for both weaker and stronger action agents, with gains of +8.3 pp on Terminal-Bench and +6.8 pp on $\tau^2$-Bench. Ablations show that selective intervention outperforms passive bank exposure, always-on injection, advisor-only guidance, and general retrieval. As an early step toward open-weight memory policies, we train Qwen3.5-27B on SETA using SFT and GRPO, improving validation reward and achieving partial transfer to Terminal-Bench.",Yifan Wu; Lizhu Zhang; Yuhang Zhou; Mingyi Wang; Bo Peng; Serena Li; Xiangjun Fan; Zhuokai Zhao,2026-07-09,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.08716,,2026-07-18T08:16:45+00:00
ale-0390,"What to Keep, What to Forget: A Rate-Distortion View of Memory Compaction",https://arxiv.org/abs/2607.08032,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08032,https://arxiv.org/abs/2607.08032,text/html; charset=utf-8,"[2607.08032] What to Keep, What to Forget: A Rate--Distortion View of Memory Compaction in LLMs and Agents","Large language models, and the agents built on them, spend an ever-growing share of their compute and memory on remembering: caching attention keys and values, carrying long prompts, maintaining recurrent state, and storing what happened in previous turns and sessions. Because none of this memory is free, four largely separate research communities have each learned to compact it. They evict or quantize the KV cache, prune or distill prompts, bound architectural state, and consolidate agent memory. We argue that these are instances of one problem: a rate--distortion decision about what context-derived information to retain versus discard, at what fidelity, under a resource budget, so as to preserve downstream task utility. We make this lens precise with a single compaction objective and a layer-agnostic lower bound, use it to build a seven-axis taxonomy that classifies methods from across the stack uniformly, and use it to transfer mechanisms between layers that have never been connected, from serving-stack KV management to agent long-term memory. Two patterns hold across the survey. At every layer the signal that decides what to keep is attention magnitude or recency, and it fails in the same way everywhere, by discarding, before the query is known and with no way to undo it, information the query later needs. And while compression is measured carefully on single-turn long context, the repeated compaction that agents actually perform is almost never measured, and no benchmark holds one budget axis across all the layers at once. We turn both observations into a benchmark proposal, a small reference experiment, and a set of compaction-aware design principles, and we map the open problems.",Ashwin Gerard Colaco; Nada Lahjouji,2026-07-09,2026,arXiv,arXiv,,,cs.LG,arxiv-api,,,,,,,,,2607.08032,,2026-07-18T08:16:45+00:00
ale-0391,A Hierarchical Memory Architecture Overcomes Context Limits in Long-Horizon Multi-Agent Modeling,https://arxiv.org/abs/2607.07666,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07666,https://arxiv.org/abs/2607.07666,text/html; charset=utf-8,[2607.07666] A hierarchical memory architecture overcomes context limits in long-horizon multi-agent computational modeling,"Large language models (LLMs) demonstrate remarkable reasoning capabilities, yet their stateless architecture fundamentally limits deployment in long-horizon research workflows requiring multi-session continuity and quantitative rigor. Here we present Ensemble QSP, a multi-agent framework featuring a three-layer hierarchical memory architecture that keeps injected context bounded and constant in project duration (mid-term project state: median 301 tokens, max 4,050, across 104 runs) by capping each state category and evicting completed work, enabling continuous autonomous operation without context degradation. The system orchestrates five specialist worker agents under domain-expert principal investigators, enforcing physical constraints through physics-based checklists and structured-domain knowledge. Comprehensive benchmarking demonstrates robust autonomous pharmacokinetic-pharmacodynamic model selection without human intervention, consistent result quality across both lower-cost and frontier LLMs, improved PK parameter recovery relative to single-agent baselines, and stable model selection across linguistically diverse prompts of the same task. Feature-level ablation across physiologically based pharmacokinetic (PBPK) models spanning a broad complexity range shows that PI-agent oversight improves debugging efficiency while preserving final accuracy across conditions. The architecture is structurally domain-agnostic, adding a new scientific domain requires only a new PI agent configuration.",Shivendra G. Tewari; Holly Kimko,2026-07-08,2026,arXiv,arXiv,,"19 pages, 4 figures, 2 tables. Preprint submitted for publication",q-bio.QM,arxiv-api,,,,,,,,,2607.07666,,2026-07-18T08:16:45+00:00
ale-0392,SkillCenter: A Large-Scale Source-Grounded Skill Library for Autonomous AI Agents,https://arxiv.org/abs/2607.07676,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07676,https://arxiv.org/abs/2607.07676,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0393,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,ok,200,https://entire.io/blog/how-version-control-will-evolve-for-the-agent-boom,https://entire.io/blog/how-version-control-will-evolve-for-the-agent-boom,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0394,self-learning-skills,https://github.com/Kulaxyz/self-learning-skills,external,github.com,ok,200,https://github.com/Kulaxyz/self-learning-skills,https://github.com/Kulaxyz/self-learning-skills,text/html; charset=utf-8,"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,888,37,2,"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.",MIT,2026-06-28T19:30:36Z,2026-07-18T07:23:16Z,,,2026-07-18T08:16:45+00:00
ale-0395,GitLake: Git-for-data for the agentic lakehouse,https://arxiv.org/abs/2607.08319,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08319,https://arxiv.org/abs/2607.08319,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0396,Shared Selective Persistent Memory for Agentic LLM Systems,https://arxiv.org/abs/2607.09493,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.09493,https://arxiv.org/abs/2607.09493,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0397,Scoped Verification for Reliable Long-Horizon Agentic Context Evolution,https://arxiv.org/abs/2607.09175,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.09175,https://arxiv.org/abs/2607.09175,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0398,AgentMemory,https://github.com/rohitg00/agentmemory,external,github.com,ok,200,https://github.com/rohitg00/agentmemory,https://github.com/rohitg00/agentmemory,text/html; charset=utf-8,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,25307,2098,389,#1 Persistent memory for AI coding agents based on real-world benchmarks,Apache-2.0,2026-02-25T07:32:52Z,2026-07-18T07:22:58Z,,,2026-07-18T08:16:45+00:00
ale-0399,TencentDB-Agent-Memory,https://github.com/TencentCloud/TencentDB-Agent-Memory,external,github.com,ok,200,https://github.com/TencentCloud/TencentDB-Agent-Memory,https://github.com/TencentCloud/TencentDB-Agent-Memory,text/html; charset=utf-8,"GitHub - TencentCloud/TencentDB-Agent-Memory: TencentDB Agent Memory delivers fully local long-term memory for AI Agents via a 4-tier progressive pipeline, with zero external API dependencies. · GitHub","TencentDB Agent Memory delivers fully local long-term memory for AI Agents via a 4-tier progressive pipeline, with zero external API dependencies. - TencentCloud/TencentDB-Agent-Memory",,2026-04-07,2026,TencentCloud/TencentDB-Agent-Memory,GitHub,,,,github-api,TencentCloud/TencentDB-Agent-Memory,9082,842,301,"TencentDB Agent Memory delivers fully local long-term memory for AI Agents via a 4-tier progressive pipeline, with zero external API dependencies.",NOASSERTION,2026-04-07T06:34:26Z,2026-07-18T07:59:20Z,,,2026-07-18T08:16:45+00:00
ale-0400,agent-memory (Neo4j Labs),https://github.com/neo4j-labs/agent-memory,external,github.com,ok,200,https://github.com/neo4j-labs/agent-memory,https://github.com/neo4j-labs/agent-memory,text/html; charset=utf-8,"GitHub - neo4j-labs/agent-memory: A graph-native memory system for AI agents and context graphs. Store conversations, build knowledge graphs, and let your agents learn from their own reasoning — all backed by Neo4j. · GitHub","A graph-native memory system for AI agents and context graphs. Store conversations, build knowledge graphs, and let your agents learn from their own reasoning — all backed by Neo4j. - neo4j-labs/agent-memory",,2026-01-06,2026,neo4j-labs/agent-memory,GitHub,,,,github-api,neo4j-labs/agent-memory,375,86,79,"A graph-native memory system for AI agents and context graphs. Store conversations, build knowledge graphs, and let your agents learn from their own reasoning — all backed by Neo4j.",Apache-2.0,2026-01-06T23:07:16Z,2026-07-17T21:56:30Z,,,2026-07-18T08:16:45+00:00
ale-0401,re_gent,https://github.com/regent-vcs/re_gent,external,github.com,ok,200,https://github.com/regent-vcs/re_gent,https://github.com/regent-vcs/re_gent,text/html; charset=utf-8,GitHub - regent-vcs/re_gent: Version-Control for AI coding agents. · GitHub,Version-Control for AI coding agents. Contribute to regent-vcs/re_gent development by creating an account on GitHub.,,2026-04-30,2026,regent-vcs/re_gent,GitHub,,,,github-api,regent-vcs/re_gent,780,57,28,Version-Control for AI coding agents.,Apache-2.0,2026-04-30T09:09:41Z,2026-07-15T15:28:45Z,,,2026-07-18T08:16:45+00:00
ale-0402,StructAgent: Harness Long-Horizon Digital Agents with Unified Causal Structure,https://arxiv.org/abs/2607.11388,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.11388,https://arxiv.org/abs/2607.11388,text/html; charset=utf-8,[2607.11388] StructAgent: Harness Long-horizon Digital Agents with Unified Causal Structure,"Recent advances in large language models (LLMs) and vision-language models (VLMs) have enabled increasingly capable digital agents for computer use. However, real-world tasks are often long-horizon and involve evolving contexts containing accumulated observations, intermediate edits, failed attempts, and partially completed executions. Existing agents typically operate over raw interaction history, making task progress difficult to interpret, verify, and recover, which ultimately limits reliable long-horizon execution. In this paper, we argue that addressing this challenge requires explicitly structuring both the agent's state and workflow around a unified causal representation of task progress. We present \textbf{StructAgent}, a state-centered framework that introduces a unified state for maintaining compact, verifiable task progress and a structured workflow that regulates progress through verifier-backed state transitions. Building on this design, StructAgent further enables explicit progress checkpointing, evidence-driven task completion, targeted failure recovery, and tool-supported execution, while ensuring that all progress updates remain grounded in verification. Extensive experiments demonstrate that StructAgent consistently improves a wide range of LLM and VLM backbones on long-horizon computer-use tasks. On OSWorld-Verified, it improves Qwen3.5-9B from 27.0\% to 46.9\% success rate and Qwen3.5-27B from 31.6\% to 62.2\%, while achieving a new open-source state of the art of 78.9\% with MiniMax-M3. Moreover, the same framework generalizes beyond desktop environments to Minecraft, demonstrating the generality of our design.",Wenyi Wu; Sibo Zhu; Kun Zhou; Aayush Salvi; Zixuan Song; Biwei Huang,2026-07-13,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.11388,,2026-07-18T08:16:45+00:00
ale-0403,The Compliance Trap: Diagnosing How AI Agents Consume Conflicting Memory,https://arxiv.org/abs/2607.10608,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.10608,https://arxiv.org/abs/2607.10608,text/html; charset=utf-8,[2607.10608] The Compliance Trap: Diagnosing How AI Agents Consume Conflicting Memory,"Memory is becoming a core component of long-horizon AI agents, allowing agents to reuse past experience when operating web browsers, software tools, and other interactive environments. Existing work mostly treats memory as a supply problem, asking what experience to write, how to store it, and which entry to retrieve for the next task. Yet we still lack a clear account of how models consume retrieved memory across a multi-step action trajectory. This consumption process matters because it determines not only what memories should be retrieved, but also what models and control policies are needed to use them safely. To diagnose this process, we propose Entry--Propagation--Recovery (E-P-R), a trajectory-level framework that asks where memory first changes an action, whether that change carries forward, and whether the agent can recover after leaving a correct path. We instantiate E-P-R on WebArena and on MemTrapBench, a controlled benchmark we build to isolate these phases. We find that the main failure often begins at entry: agents adopt conflicting memory at the first exposed decision point even when it is task-wrong. Repeated exposure then amplifies this early error, while recovery after divergence is weak. Together, these effects create a compliance trap: across models, conflicting memory induces similar compliance rates, but once agents comply, their success rates collapse to a low floor. Stronger agents therefore suffer larger absolute damage because each compliance event erases more baseline capability. These results suggest that memory-augmented agents should be evaluated not only by retrieval quality or final success rate, but by how they consume memory throughout the trajectory.",Yixiong Chen; Xinyi Bai; Alan Yuille,2026-07-12,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.10608,,2026-07-18T08:16:45+00:00
ale-0404,"Conversational Context: Session, State, and Memory",https://adk.dev/sessions/,external,adk.dev,ok,200,https://adk.dev/sessions/,https://adk.dev/sessions/,text/html; charset=utf-8,"Conversational Context: Session, State, and Memory - 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-18T08:16:45+00:00
ale-0405,Persistence,https://docs.langchain.com/oss/python/langgraph/persistence,external,docs.langchain.com,ok,200,https://docs.langchain.com/oss/python/langgraph/persistence,https://docs.langchain.com/oss/python/langgraph/persistence,text/html; charset=utf-8,Persistence - Docs by LangChain,LangGraph's persistence layer gives agents short-term memory through checkpointers and long-term memory through stores.,LangChain,,,LangGraph,LangChain,,,,primary-page,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0406,Workflow checkpoints,https://learn.microsoft.com/en-us/agent-framework/workflows/checkpoints,external,learn.microsoft.com,ok,200,https://learn.microsoft.com/en-us/agent-framework/workflows/checkpoints,https://learn.microsoft.com/en-us/agent-framework/workflows/checkpoints,text/html,Microsoft Agent Framework Workflows - Checkpoints | Microsoft Learn,In-depth look at Checkpoints in Microsoft Agent Framework Workflows.,Microsoft,,,Microsoft Agent Framework,Microsoft,,,,primary-page,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0407,Agent state,https://strandsagents.com/docs/user-guide/concepts/agents/state/,external,strandsagents.com,ok,200,https://strandsagents.com/docs/user-guide/concepts/agents/state/,https://strandsagents.com/docs/user-guide/concepts/agents/state/,text/html; charset=utf-8,State Management | Strands Agents,The open source toolkit for building production agents.,Strands Agents,,,Strands Agents,Strands Agents,,,,primary-page,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0408,Memory as a Controlled Process: Learned Adaptive Memory Management for LLM Agents,https://arxiv.org/abs/2607.13591,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.13591,https://arxiv.org/abs/2607.13591,text/html; charset=utf-8,[2607.13591] Memory as a Controlled Process: Learned Adaptive Memory Management for LLM Agents,"Large Language Model (LLM) agents increasingly rely on external memory systems to accumulate experience across tasks. Yet nearly all existing approaches, from graph-structured memories to reflective insight stores, access memory through fixed, hand-designed heuristics. We argue that this static view of memory is a core bottleneck for agentic learning because optimal memory behavior is fundamentally context-dependent. The early stages of the tasks, benefit from minimal retrieval because memory is sparse; recurring goal types benefit from plan reuse rather than generic nearest-neighbor lookup; stuck agents benefit from re-retrieval with alternative queries; and across long task streams, the memory store itself must be consolidated and pruned to remain useful. We present Memory as a Controlled Process (MemCon), a framework that models memory operations as a Markov Decision Process and learns an online policy that adaptively decides when, what, and how much to retrieve, when to inject a distilled plan, and when to consolidate or forget. MemCon is backend-agnostic: it wraps any existing memory implementation, learns from task-by-task binary feedback with no pretraining and no additional LLM calls, and uses a lightweight tabular contextual bandit with UCB exploration that converges within tens of tasks. Across 6 benchmarks, 3 agent frameworks, and 3 LLM backbones, MemCon consistently outperforms multiple memory baselines by up to 15.2 points in task success while reducing token consumption by 5--20%.",Eric Hanchen Jiang; Zhi Zhang; Yuchen Wu; Levina Li; Dong Liu; Xiao Liang; Rui Sun; Yubei Li; Edward Sun; Haozheng Luo; Zhaolu Kang; Aylin Caliskan; Kai-Wei Chang; Ying Nian Wu,2026-07-15,2026,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,,,2607.13591,,2026-07-18T08:16:45+00:00
ale-0409,Why Git Is the Memory Solution for the Agentic Development Lifecycle,https://arxiv.org/abs/2607.14390,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14390,https://arxiv.org/abs/2607.14390,text/html; charset=utf-8,[2607.14390] Why Git Is the Memory Solution for the Agentic Development Lifecycle,"Coding agents now produce a growing share of a team's code, while the reasoning behind each change -- the alternatives weighed, the constraints discovered, the approaches rejected -- is trapped in assistant transcripts that vanish with the session. Memory for this setting, the agentic development lifecycle (ADLC), is usually posed as one retrieval problem and built as machinery: tiered stores, memory graphs, compiled wikis, model-judged admission. We argue memory should instead be git-bound -- built into the repository's version control, inheriting the guarantees the machinery struggles to construct: ground truth from commits, freshness from rebuild, verification from the merge, containment from review. On this ledger we solve two problems separately, then combine them. Seed supply is closed as an eight-corpus retrieval study under a pre-registered ship discipline: five imported ranking mechanisms rejected, two kept, and a best configuration of ~0.31 pooled MRR -- ~60x the raw-transcript grep floor, ~15x an honest parsed-turn floor. Answer assembly is where ranking stops helping: single-shot retrieval scores only 0.07-0.20 answer-sufficiency on real developer questions, and ungated episode injection measurably degrades good answers. A router dispatches breadth to a git-anchored structural map, pointed lookups to confidence-gated episodes, and rationale to decision synthesis, which reconstructs why-arcs no single session contains (0.83 sufficiency on a young ~50k-LOC production system). Routed, the system answers at 382-980 tokens per question -- three orders of magnitude below the recorded history. Because ground truth is mined from commit-session links rather than annotated, every result is replicable on any user's own history at zero labeling cost. The remaining constraint is capture. Code, benchmark, and paper source: github.com/rekal-dev/rekal-cli.",Frank Guo,2026-07-15,2026,arXiv,arXiv,,8 pages,cs.SE,arxiv-api,,,,,,,,,2607.14390,,2026-07-18T08:16:45+00:00
ale-0410,ReasoningBank: Scaling Agent Self-Evolving with Reasoning Memory,https://arxiv.org/abs/2509.25140,external,arxiv.org,ok,200,https://arxiv.org/abs/2509.25140,https://openreview.net/forum?id=jL7fwchScm,text/html; charset=utf-8,[2509.25140] ReasoningBank: Scaling Agent Self-Evolving with Reasoning Memory,"With the growing adoption of large language model agents in persistent real-world roles, they naturally encounter continuous streams of tasks. A key limitation, however, is their failure to learn from the accumulated interaction history, forcing them to discard valuable insights and repeat past errors. We propose ReasoningBank, a novel memory framework that distills generalizable reasoning strategies from an agent's self-judged successful and failed experiences. At test time, an agent retrieves relevant memories from ReasoningBank to inform its interaction and then integrates new learnings back, enabling it to become more capable over time. Building on this powerful experience learner, we further introduce memory-aware test-time scaling (MaTTS), which accelerates and diversifies this learning process by scaling up the agent's interaction experience. By allocating more compute to each task, the agent generates abundant, diverse experiences that provide rich contrastive signals for synthesizing higher-quality memory. The better memory in turn guides more effective scaling, establishing a powerful synergy between memory and test-time scaling. Across web browsing and software engineering benchmarks, ReasoningBank consistently outperforms existing memory mechanisms that store raw trajectories or only successful task routines, improving both effectiveness and efficiency; MaTTS further amplifies these gains. These findings establish memory-driven experience scaling as a new scaling dimension, enabling agents to self-evolve with emergent behaviors naturally arise. Our code can be found at https://github.com/google-research/reasoning-bank.",Siru Ouyang; Jun Yan; I-Hung Hsu; Yanfei Chen; Ke Jiang; Zifeng Wang; Rujun Han; Long T. Le; Samira Daruki; Xiangru Tang; Vishy Tirumalashetty; George Lee; Mahsan Rofouei; Hangfei Lin; Jiawei Han; Chen-Yu Lee; Tomas Pfister,2026,2026,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,OpenReview proceedings record,,,,,,,,,2509.25140,,2026-07-18T08:16:45+00:00
ale-0411,Scaling Long-Horizon LLM Agent via Context-Folding,https://arxiv.org/abs/2510.11967,external,arxiv.org,ok,200,https://arxiv.org/abs/2510.11967,https://arxiv.org/abs/2510.11967,text/html; charset=utf-8,[2510.11967] Scaling Long-Horizon LLM Agent via Context-Folding,"Large language model (LLM) agents are fundamentally constrained by context length on long-horizon tasks. We introduce Context-Folding, a framework that empowers agents to actively manage their working context. An agent can procedurally branch into a sub-trajectory to handle a subtask and then fold it upon completion, collapsing the intermediate steps while retaining a concise summary of the outcome. To make this behavior learnable, we develop an end-to-end reinforcement learning framework FoldGRPO with specific process rewards to encourage effective task decomposition and context management. On complex long-horizon tasks (Deep Research and SWE), our folding agent matches or outperforms the ReAct baselines while using an active context 10$\times$ smaller and significantly outperforms models that rely on summarization-based context management.",Weiwei Sun; Miao Lu; Zhan Ling; Kang Liu; Xuesong Yao; Yiming Yang; Jiecao Chen,2025-10-13,2025,arXiv,arXiv,,,cs.CL,arxiv-api,,,,,,,,,2510.11967,,2026-07-18T08:16:45+00:00
ale-0412,AutoGen,https://github.com/microsoft/autogen,external,github.com,ok,200,https://github.com/microsoft/autogen,https://github.com/microsoft/autogen,text/html; charset=utf-8,GitHub - microsoft/autogen: A programming framework for agentic AI · GitHub,A programming framework for agentic AI. Contribute to microsoft/autogen development by creating an account on GitHub.,,2023-08-18,2023,microsoft/autogen,GitHub,,,,github-api,microsoft/autogen,59802,9000,964,A programming framework for agentic AI,CC-BY-4.0,2023-08-18T11:43:45Z,2026-07-18T08:05:36Z,,,2026-07-18T08:16:45+00:00
ale-0413,Microsoft Agent Framework,https://github.com/microsoft/agent-framework,external,github.com,ok,200,https://github.com/microsoft/agent-framework,https://github.com/microsoft/agent-framework,text/html; charset=utf-8,"GitHub - microsoft/agent-framework: A framework for building, orchestrating and deploying AI agents and multi-agent workflows with support for Python and .NET. · GitHub","A framework for building, orchestrating and deploying AI agents and multi-agent workflows with support for Python and .NET. - microsoft/agent-framework",,2025-04-28,2025,microsoft/agent-framework,GitHub,,,,github-api,microsoft/agent-framework,12198,2051,641,"A framework for building, orchestrating and deploying AI agents and multi-agent workflows with support for Python and .NET.",MIT,2025-04-28T19:40:42Z,2026-07-18T07:47:17Z,,,2026-07-18T08:16:45+00:00
ale-0414,LangGraph,https://github.com/langchain-ai/langgraph,external,github.com,ok,200,https://github.com/langchain-ai/langgraph,https://github.com/langchain-ai/langgraph,text/html; charset=utf-8,GitHub - langchain-ai/langgraph: Build resilient agents. · GitHub,Build resilient agents. Contribute to langchain-ai/langgraph development by creating an account on GitHub.,,2023-08-09,2023,langchain-ai/langgraph,GitHub,,,,github-api,langchain-ai/langgraph,37537,6289,625,Build resilient agents.,MIT,2023-08-09T18:33:12Z,2026-07-18T08:10:44Z,,,2026-07-18T08:16:45+00:00
ale-0415,CrewAI,https://github.com/crewAIInc/crewAI,external,github.com,ok,200,https://github.com/crewAIInc/crewAI,https://github.com/crewAIInc/crewAI,text/html; charset=utf-8,"GitHub - crewAIInc/crewAI: Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks. · GitHub","Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks. - crewAIInc/crewAI",,2023-10-27,2023,crewAIInc/crewAI,GitHub,,,,github-api,crewAIInc/crewAI,55716,7867,652,"Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.",MIT,2023-10-27T03:26:59Z,2026-07-18T07:37:55Z,,,2026-07-18T08:16:45+00:00
ale-0416,LlamaIndex Workflows,https://developers.llamaindex.ai/python/llamaagents/workflows/,external,developers.llamaindex.ai,ok,200,https://developers.llamaindex.ai/python/llamaagents/workflows/,https://developers.llamaindex.ai/python/llamaagents/workflows/,text/html; charset=utf-8,Introduction | Developer Documentation,,,,,,Developer Documentation,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0417,OpenAI Agents SDK handoffs,https://openai.github.io/openai-agents-python/handoffs/,external,openai.github.io,ok,200,https://openai.github.io/openai-agents-python/handoffs/,https://openai.github.io/openai-agents-python/handoffs/,text/html; charset=utf-8,Handoffs - OpenAI Agents SDK,,,,,,openai.github.io,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0418,Agent Protocol,https://agentprotocol.ai/,external,agentprotocol.ai,ok,200,https://agentprotocol.ai/,https://agentprotocol.ai/,text/html; charset=utf-8,AgentProtocol.ai — A practical guide to AI agent communication standards.,"AgentProtocol.ai is an independent, vendor-neutral guide to AI agent communication standards — MCP, A2A, Agent Protocol, AI agent APIs and agent interoperability.",AgentProtocol.ai,,,,AgentProtocol.ai,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0419,AgentKit,https://github.com/inngest/agent-kit,external,github.com,ok,200,https://github.com/inngest/agent-kit,https://github.com/inngest/agent-kit,text/html; charset=utf-8,GitHub - inngest/agent-kit: AgentKit: Build multi-agent networks in TypeScript with deterministic routing and rich tooling via MCP. · GitHub,AgentKit: Build multi-agent networks in TypeScript with deterministic routing and rich tooling via MCP. - inngest/agent-kit,,2024-11-18,2024,inngest/agent-kit,GitHub,,,,github-api,inngest/agent-kit,913,136,46,AgentKit: Build multi-agent networks in TypeScript with deterministic routing and rich tooling via MCP.,Apache-2.0,2024-11-18T05:28:42Z,2026-07-13T12:05:29Z,,,2026-07-18T08:16:45+00:00
ale-0420,deepagents,https://github.com/langchain-ai/deepagents,external,github.com,ok,200,https://github.com/langchain-ai/deepagents,https://github.com/langchain-ai/deepagents,text/html; charset=utf-8,GitHub - langchain-ai/deepagents: The batteries-included agent harness. · GitHub,The batteries-included agent harness. Contribute to langchain-ai/deepagents development by creating an account on GitHub.,,2025-07-27,2025,langchain-ai/deepagents,GitHub,,,,github-api,langchain-ai/deepagents,26393,3700,168,The batteries-included agent harness.,MIT,2025-07-27T23:07:53Z,2026-07-18T08:10:16Z,,,2026-07-18T08:16:45+00:00
ale-0421,Temporal for AI,https://temporal.io/solutions/ai,external,temporal.io,ok,200,https://temporal.io/solutions/ai,https://temporal.io/solutions/ai,text/html; charset=utf-8,Temporal for AI | Temporal,"Temporal is a durable workflow platform that ensures AI applications run reliably, every time. Build faster, prevent failures, and stand out from the crowd.",,,,,temporal.io,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0422,Restate,https://restate.dev/,external,restate.dev,ok,200,https://www.restate.dev/,https://www.restate.dev/,text/html; charset=utf-8,Restate - Build innately resilient distributed apps,Restate is a lightweight runtime that lets developers build innately resilient distributed apps without the complexity tax.,,,,,Restate,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0423,DBOS,https://www.dbos.dev/,external,www.dbos.dev,ok,200,https://www.dbos.dev/,https://www.dbos.dev/,text/html; charset=utf-8,DBOS | Durable Workflow Orchestration,"DBOS is an open source durable execution and workflow orchestration system that radically simplifies the development and operation of reliable, observable workflows.",,,,,dbos.dev,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0424,Composio Agent Orchestrator,https://github.com/ComposioHQ/agent-orchestrator,external,github.com,ok,200,https://github.com/AgentWrapper/agent-orchestrator,https://github.com/AgentWrapper/agent-orchestrator,text/html; charset=utf-8,"GitHub - AgentWrapper/agent-orchestrator: AO is an agent IDE, that helps developers manage fleets of coding agents to do your day to day tasks for parallel coding agents. It comes with an agentic orchestrator that plans tasks, spawns agents, and autonomously handles CI fixes, merge conflicts, and code reviews. · GitHub","AO is an agent IDE, that helps developers manage fleets of coding agents to do your day to day tasks for parallel coding agents. It comes with an agentic orchestrator that plans tasks, spawns agents, and autonomously handles CI fixes, merge conflicts, and code reviews. - AgentWrapper/agent-orchestrator",,2026-02-13,2026,ComposioHQ/agent-orchestrator,GitHub,,,,github-api,ComposioHQ/agent-orchestrator,8343,1204,523,"AO is an agent IDE, that helps developers manage fleets of coding agents to do your day to day tasks for parallel coding agents. It comes with an agentic orchestrator that plans tasks, spawns agents, and autonomously handles CI fixes, merge conflicts, and code reviews.",Apache-2.0,2026-02-13T09:52:36Z,2026-07-18T07:52:28Z,,,2026-07-18T08:16:45+00:00
ale-0425,Omnigent,https://github.com/omnigent-ai/omnigent,external,github.com,ok,200,https://github.com/omnigent-ai/omnigent,https://github.com/omnigent-ai/omnigent,text/html; charset=utf-8,"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,7440,1065,589,"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.",Apache-2.0,2026-06-11T12:18:13Z,2026-07-18T08:02:22Z,,,2026-07-18T08:16:45+00:00
ale-0426,From Agent Loops to Structured Graphs: A Scheduler-Theoretic Framework for LLM Agent Execution,https://arxiv.org/abs/2604.11378,external,arxiv.org,ok,200,https://arxiv.org/abs/2604.11378,https://arxiv.org/abs/2604.11378,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0427,Eve,https://github.com/vercel/eve,external,github.com,ok,200,https://github.com/vercel/eve,https://github.com/vercel/eve,text/html; charset=utf-8,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,3835,352,302,The Framework for Building Agents,Apache-2.0,2026-06-16T10:51:20Z,2026-07-18T08:08:51Z,,,2026-07-18T08:16:45+00:00
ale-0428,Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework,https://arxiv.org/abs/2603.11445,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.11445,https://openreview.net/forum?id=WUmz4LUbvU,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0429,From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents,https://arxiv.org/abs/2603.22386,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.22386,https://arxiv.org/abs/2603.22386,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0430,Agent-as-a-Router,https://github.com/LanceZPF/agent-as-a-router,external,github.com,ok,200,https://github.com/LanceZPF/agent-as-a-router,https://github.com/LanceZPF/agent-as-a-router,text/html; charset=utf-8,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,685,15,0,The official implementations of Agent-as-a-Router: Agentic Model Routing for Coding Tasks.,MIT,2026-06-20T16:00:51Z,2026-07-18T08:13:37Z,,,2026-07-18T08:16:45+00:00
ale-0431,Amp: Custom Agents,https://ampcode.com/news/custom-agents,external,ampcode.com,ok,200,https://ampcode.com/news/custom-agents,https://ampcode.com/news/custom-agents,text/html,Custom Agents - Amp,"Plugins can now create agents, run them once, and keep talking to their threads.",,,,,ampcode.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0432,AgentsMesh,https://github.com/AgentsMesh/AgentsMesh,external,github.com,ok,200,https://github.com/AgentsMesh/AgentsMesh,https://github.com/AgentsMesh/AgentsMesh,text/html; charset=utf-8,"GitHub - AgentsMesh/AgentsMesh: The AI Agent Workforce Platform. Run a hundred AI coding agents across your own machines — schedule, isolate, and steer them all from one console. · GitHub","The AI Agent Workforce Platform. Run a hundred AI coding agents across your own machines — schedule, isolate, and steer them all from one console. - AgentsMesh/AgentsMesh",,2026-02-28,2026,AgentsMesh/AgentsMesh,GitHub,,,,github-api,AgentsMesh/AgentsMesh,2282,228,17,"The AI Agent Workforce Platform. Run a hundred AI coding agents across your own machines — schedule, isolate, and steer them all from one console.",NOASSERTION,2026-02-28T07:10:42Z,2026-07-17T17:35:23Z,,,2026-07-18T08:16:45+00:00
ale-0433,Bernstein,https://github.com/sipyourdrink-ltd/bernstein,external,github.com,ok,200,https://github.com/sipyourdrink-ltd/bernstein,https://github.com/sipyourdrink-ltd/bernstein,text/html; charset=utf-8,"GitHub - sipyourdrink-ltd/bernstein: Deterministic, audit-grade multi-agent orchestration for AI agents (Claude Code, Codex, Gemini CLI, +40 more). HMAC-chained audit log, signed agent cards, per-artefact lineage, byte-identical replay with divergence detection, air-gap deploy. https://bernstein.run · GitHub","Deterministic, audit-grade multi-agent orchestration for AI agents (Claude Code, Codex, Gemini CLI, +40 more). HMAC-chained audit log, signed agent cards, per-artefact lineage, byte-identical replay with divergence detection, air-gap deploy. https://bernstein.run - sipyourdrink-ltd/bernstein",,2026-03-22,2026,sipyourdrink-ltd/bernstein,GitHub,,,,github-api,sipyourdrink-ltd/bernstein,690,64,59,"Deterministic, audit-grade multi-agent orchestration for AI agents (Claude Code, Codex, Gemini CLI, +40 more). HMAC-chained audit log, signed agent cards, per-artefact lineage, byte-identical replay with divergence detection, air-gap deploy. https://bernstein.run",Apache-2.0,2026-03-22T14:52:26Z,2026-07-18T08:13:31Z,,,2026-07-18T08:16:45+00:00
ale-0434,Aeon,https://github.com/aaronjmars/aeon,external,github.com,ok,200,https://github.com/aeonfun/aeon,https://github.com/aeonfun/aeon,text/html; charset=utf-8,"GitHub - aeonfun/aeon: The most autonomous agent framework. No approval loops. No babysitting. Configure once, forget forever. · GitHub","The most autonomous agent framework. No approval loops. No babysitting. Configure once, forget forever. - aeonfun/aeon",,2026-03-04,2026,aaronjmars/aeon,GitHub,,,,github-api,aaronjmars/aeon,578,208,6,"The most autonomous agent framework. No approval loops. No babysitting. Configure once, forget forever.",MIT,2026-03-04T19:44:49Z,2026-07-17T18:12:23Z,,,2026-07-18T08:16:45+00:00
ale-0435,h5i,https://github.com/h5i-dev/h5i,external,github.com,ok,200,https://github.com/h5i-dev/h5i,https://github.com/h5i-dev/h5i,text/html; charset=utf-8,"GitHub - h5i-dev/h5i: Auditable workspaces for AI coding agents: sandboxed worktrees, programmable multi-agent orchestration, automated security checks, up to 95% less token waste, and persistent memory. · GitHub","Auditable workspaces for AI coding agents: sandboxed worktrees, programmable multi-agent orchestration, automated security checks, up to 95% less token waste, and persistent memory. - h5i-dev/h5i",,2026-03-11,2026,h5i-dev/h5i,GitHub,,,,github-api,h5i-dev/h5i,470,39,31,"Auditable workspaces for AI coding agents: sandboxed worktrees, programmable multi-agent orchestration, automated security checks, up to 95% less token waste, and persistent memory.",Apache-2.0,2026-03-11T04:30:52Z,2026-07-17T11:59:25Z,,,2026-07-18T08:16:45+00:00
ale-0436,SwarmResearch: Orchestrating Coding Agents for Open-Ended Discovery,https://arxiv.org/abs/2607.02807,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.02807,https://arxiv.org/abs/2607.02807,text/html; charset=utf-8,[2607.02807] SwarmResearch: Orchestrating Coding Agents for Open-Ended Discovery,"Long-running coding agents such as autoresearch can persistently discover optimizations for open-ended problems. However, they tend to converge onto a single high-level approach, then proceed with low-level edits while missing other superior approaches to the problem. We hypothesize two harness-level design choices contribute to this behavior: accumulating context in a single long-running agent and only exposing a single program state to edit. We introduce SwarmResearch, an orchestrator-subagent harness in which a Shepherd Agent uses global context to steer a population of Search Agents, each operating with local context in their respective git branch. On open-ended optimization tasks, SwarmResearch discovers better or comparable solutions to state-of-the-art LLM-guided evolution and multi-agent techniques on 13/15 tasks, driven by higher-level exploration. Compared with fixed scaling of serial and parallel agents, SwarmResearch's orchestrator-guided scaling discovers better-performing solutions by adapting parallelism at different search depths.",Yuvraj Virk; Zack Edds; Chunqiu Steven Xia; Lingming Zhang,2026-07-02,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.02807,,2026-07-18T08:16:45+00:00
ale-0437,Scaling Long-Running Autonomous Coding,https://cursor.com/blog/scaling-agents,external,cursor.com,ok,200,https://cursor.com/blog/scaling-agents,https://cursor.com/blog/scaling-agents,text/html; charset=utf-8,Scaling long-running autonomous coding · Cursor,We've been experimenting with running coding agents autonomously for weeks at a time.,Wilson Lin,,,,Cursor,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0438,babysitter,https://github.com/a5c-ai/babysitter,external,github.com,ok,200,https://github.com/a5c-ai/babysitter,https://github.com/a5c-ai/babysitter,text/html; charset=utf-8,"GitHub - a5c-ai/babysitter: Babysitter enforces obedience on agentic workforces and enables them to manage extremely complex tasks and workflows through deterministic, hallucination-free self-orchestration · GitHub","Babysitter enforces obedience on agentic workforces and enables them to manage extremely complex tasks and workflows through deterministic, hallucination-free self-orchestration - a5c-ai/babysitter",,2026-01-05,2026,a5c-ai/babysitter,GitHub,,,,github-api,a5c-ai/babysitter,1559,91,115,"Babysitter enforces obedience on agentic workforces and enables them to manage extremely complex tasks and workflows through deterministic, hallucination-free self-orchestration",MIT,2026-01-05T15:26:53Z,2026-07-18T03:14:47Z,,,2026-07-18T08:16:45+00:00
ale-0439,claude-code-merge-queue,https://github.com/funador/claude-code-merge-queue,external,github.com,ok,200,https://github.com/funador/claude-code-merge-queue,https://github.com/funador/claude-code-merge-queue,text/html; charset=utf-8,GitHub - funador/claude-code-merge-queue: The local merge queue for parallel Claude Code agents · GitHub,The local merge queue for parallel Claude Code agents - funador/claude-code-merge-queue,,2026-07-10,2026,funador/claude-code-merge-queue,GitHub,,,,github-api,funador/claude-code-merge-queue,12,1,0,The local merge queue for parallel Claude Code agents,MIT,2026-07-10T22:05:05Z,2026-07-17T04:52:41Z,,,2026-07-18T08:16:45+00:00
ale-0440,Devin can now manage Devins,https://cognition.com/blog/devin-can-now-manage-devins,external,cognition.com,ok,200,https://cognition.com/blog/devin-can-now-manage-devins,https://cognition.com/blog/devin-can-now-manage-devins,text/html; charset=utf-8,Devin can now Manage Devins | Cognition,"Devin can now break down large tasks and delegate them to a team of managed Devins, with each running in its own isolated VM in parallel.",,2026-03-19,2026,,cognition.com,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0441,pilotfish,https://github.com/Nanako0129/pilotfish,external,github.com,ok,200,https://github.com/Nanako0129/pilotfish,https://github.com/Nanako0129/pilotfish,text/html; charset=utf-8,"GitHub - Nanako0129/pilotfish: Multi-model orchestration layer for Claude Code — the frontier model plans, cheaper models execute, verification guards quality. One-prompt install. · GitHub","Multi-model orchestration layer for Claude Code — the frontier model plans, cheaper models execute, verification guards quality. One-prompt install. - Nanako0129/pilotfish",,2026-07-08,2026,Nanako0129/pilotfish,GitHub,,,,github-api,Nanako0129/pilotfish,480,37,4,"Multi-model orchestration layer for Claude Code — the frontier model plans, cheaper models execute, verification guards quality. One-prompt install.",MIT,2026-07-08T10:53:34Z,2026-07-18T06:39:24Z,,,2026-07-18T08:16:45+00:00
ale-0442,fable-advisor,https://github.com/DannyMac180/fable-advisor,external,github.com,ok,200,https://github.com/DannyMac180/fable-advisor,https://github.com/DannyMac180/fable-advisor,text/html; charset=utf-8,"GitHub - DannyMac180/fable-advisor: Claude Fable as an orchestrator for Opus, GPT and Grok · GitHub","Claude Fable as an orchestrator for Opus, GPT and Grok - DannyMac180/fable-advisor",,2026-07-03,2026,DannyMac180/fable-advisor,GitHub,,,,github-api,DannyMac180/fable-advisor,529,45,6,"Claude Fable as an orchestrator for Opus, GPT and Grok",MIT,2026-07-03T01:53:51Z,2026-07-17T22:33:40Z,,,2026-07-18T08:16:45+00:00
ale-0443,agent-chief,https://github.com/SmileLikeYe/agent-chief,external,github.com,ok,200,https://github.com/SmileLikeYe/agent-chief,https://github.com/SmileLikeYe/agent-chief,text/html; charset=utf-8,"GitHub - SmileLikeYe/agent-chief: Attention is your scarcest resource. Chief is the local-first layer that guards it — turning every agent, alert, and feed into one honest call: interrupt, or not. · GitHub","Attention is your scarcest resource. Chief is the local-first layer that guards it — turning every agent, alert, and feed into one honest call: interrupt, or not. - SmileLikeYe/agent-chief",,2026-07-04,2026,SmileLikeYe/agent-chief,GitHub,,,,github-api,SmileLikeYe/agent-chief,867,3,0,"Attention is your scarcest resource. Chief is the local-first layer that guards it — turning every agent, alert, and feed into one honest call: interrupt, or not.",MIT,2026-07-04T15:28:56Z,2026-07-18T06:17:54Z,,,2026-07-18T08:16:45+00:00
ale-0444,OpenTag,https://github.com/amplifthq/opentag,external,github.com,ok,200,https://github.com/amplifthq/opentag,https://github.com/amplifthq/opentag,text/html; charset=utf-8,"GitHub - amplifthq/opentag: Open-source @agent mentions for Slack and GitHub. OpenTag routes tagged requests to Codex, Claude Code, then returns results in thread. · GitHub","Open-source @agent mentions for Slack and GitHub. OpenTag routes tagged requests to Codex, Claude Code, then returns results in thread. - amplifthq/opentag",,2026-06-24,2026,amplifthq/opentag,GitHub,,,,github-api,amplifthq/opentag,1363,73,2,"Open-source @agent mentions for Slack and GitHub. OpenTag routes tagged requests to Codex, Claude Code, then returns results in thread.",MIT,2026-06-24T08:05:12Z,2026-07-17T01:52:47Z,,,2026-07-18T08:16:45+00:00
ale-0445,herdr,https://github.com/ogulcancelik/herdr,external,github.com,ok,200,https://github.com/ogulcancelik/herdr,https://github.com/ogulcancelik/herdr,text/html; charset=utf-8,GitHub - ogulcancelik/herdr: agent multiplexer that lives in your terminal. · GitHub,agent multiplexer that lives in your terminal. Contribute to ogulcancelik/herdr development by creating an account on GitHub.,,2026-03-27,2026,ogulcancelik/herdr,GitHub,,,,github-api,ogulcancelik/herdr,17770,1121,76,agent multiplexer that lives in your terminal.,NOASSERTION,2026-03-27T17:54:33Z,2026-07-18T08:13:08Z,,,2026-07-18T08:16:45+00:00
ale-0446,Orca,https://github.com/stablyai/orca,external,github.com,ok,200,https://github.com/stablyai/orca,https://github.com/stablyai/orca,text/html; charset=utf-8,GitHub - stablyai/orca: Orca is the ADE for working with a fleet of parallel agents. Run any coding agent with your own subscription. Available on desktop and mobile. · GitHub,Orca is the ADE for working with a fleet of parallel agents. Run any coding agent with your own subscription. Available on desktop and mobile. - stablyai/orca,,2026-03-17,2026,stablyai/orca,GitHub,,,,github-api,stablyai/orca,21352,1539,1672,Orca is the ADE for working with a fleet of parallel agents. Run any coding agent with your own subscription. Available on desktop and mobile.,MIT,2026-03-17T03:28:57Z,2026-07-18T08:17:56Z,,,2026-07-18T08:16:45+00:00
ale-0447,Agentic Routing: The Harness-Native Data Flywheel,https://arxiv.org/abs/2607.11399,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.11399,https://arxiv.org/abs/2607.11399,text/html; charset=utf-8,[2607.11399] Agentic Routing: The Harness-Native Data Flywheel,"Large language model agents are increasingly executed not by a single model call, but by an execution harness that manages observation, context, control, action, state, and verification. At the same time, frontier and open models are becoming structurally specialized: a model that is strong at code editing, long-context recovery, tool use, mathematical reasoning, or low-latency response may not dominate on the other axes. This makes model selection inside an agent a core systems problem rather than a per-query serving trick. Existing routing methods mostly optimize single-turn cost-quality trade-offs and therefore miss the execution state, intermediate failures, and feedback loops that make agents different from chat completion. We propose Harness-Native agentic routing, a step-level routing paradigm that selects either a single best-fit model for cost-effective execution or multiple complementary models for ensemble-style accuracy improvement, conditioned on the full harness state. The key insight is that every routing decision naturally produces a structured data record -- consisting of the query, harness state, model choice or model set, execution trace, outcome, and cost -- whose labels are supplied by the environment rather than by the router itself. These records form a harness-native data flywheel: execution traces train better routers and harness-native models, which improve cost-quality trade-offs and generate more traces under the same budget. We instantiate this idea in OpenSquilla with a four-layer routing stack, an open LightGBM cold-start ranker, and a staged router-model path that turns logged arena records into progressively stronger routing policies. The report studies singleton and multi-model routing on agentic benchmarks including DRACO and PinchBench, and argues that agentic routing is not merely cost control, but a data engine for agent-native training.",Xinchen Liu; Hang Zhou; Yingjie Zong; Yuchuan Tian; Liuyang Song; Shuo Zhang; Yulong Li; Wei He; Mengyu Zheng; Runke Liu; Siyang Cheng; Xiang Kuang; Hailin Hu; Kai Han; Yunhe Wang,2026-07-13,2026,arXiv,arXiv,,Code: https://github.com/opensquilla/opensquilla,cs.CL,arxiv-api,,,,,,,,,2607.11399,,2026-07-18T08:16:45+00:00
ale-0448,A Formal Hierarchical Architecture for Agentic Orchestration with Stack-Based Execution,https://arxiv.org/abs/2607.11138,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.11138,https://arxiv.org/abs/2607.11138,text/html; charset=utf-8,[2607.11138] A Formal Hierarchical Architecture for Agentic Orchestration with Stack-Based Execution and Lazy Discovery,"The rapid expansion of capabilities in Large Language Model (LLM) agents has exposed a critical architectural bottleneck: when agents are given access to a flat, monolithic registry of tools, the model must evaluate hundreds or thousands of options simultaneously. This leads to decision-space explosion, context window saturation, and degraded routing accuracy. To address these limitations, this paper presents a hierarchical, skill-based architecture for agentic orchestration. Capabilities are organized as a rooted tree where internal nodes make routing decisions and leaf nodes execute deterministic tasks. The runtime enforces a single-step execution loop governed by a Last-In-First-Out (LIFO) stack, giving the agent a form of memory akin to a Pushdown Automaton, therefore enabling it to track nested execution contexts and resume deterministically from any depth. Capability discovery follows a manifest-driven, lazy-loading protocol: only the immediate children of the active node are loaded, so memory and prompt costs scale with the explored path rather than the global registry. By replacing global memory with localized stack frames, the architecture prevents outputs from one execution branch from leaking into another, establishing the isolation guarantees required for deployment in regulated enterprise environments. We also discuss UPI Help, an AI-powered digital payments support product, as a motivating production deployment context. We provide a mathematical formalization of the orchestration state, detailed algorithmic analysis of the execution loop, and controlled benchmarks comparing flat and hierarchical routing under increasing tool catalogs, multi-step workflow pressure, and visible schema-token exposure per LLM call.",Prashant Devadiga; Abhishek; Adithya Mishra; Alok Singh; Amisha Sinha; Asit Desai; Gaurang Dahad; Harshit Bhushan; Mandati Pramod Reddy; Prakhar Gupta; Rupesh Patil; Siddhi Behere,2026-07-13,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.11138,,2026-07-18T08:16:45+00:00
ale-0449,Graph-based agent workflows,https://adk.dev/graphs/,external,adk.dev,ok,200,https://adk.dev/graphs/,https://adk.dev/graphs/,text/html; charset=utf-8,Graph-based agent workflows - 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-18T08:16:45+00:00
ale-0450,Flows,https://docs.crewai.com/en/concepts/flows,external,docs.crewai.com,ok,200,https://docs.crewai.com/v1.15.4/en/concepts/flows,https://docs.crewai.com/v1.15.4/en/concepts/flows,text/html; charset=utf-8,Flows - CrewAI,Learn how to create and manage AI workflows using CrewAI Flows.,CrewAI,,,CrewAI,CrewAI,,,,primary-page,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0451,Graph,https://strandsagents.com/docs/user-guide/concepts/multi-agent/graph/,external,strandsagents.com,ok,200,https://strandsagents.com/docs/user-guide/concepts/multi-agent/graph/,https://strandsagents.com/docs/user-guide/concepts/multi-agent/graph/,text/html; charset=utf-8,Graph Multi-Agent Pattern | Strands Agents,The open source toolkit for building production agents.,Strands Agents,,,Strands Agents,Strands Agents,,,,primary-page,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0452,Towards a Science of Scaling Agent Systems,https://arxiv.org/abs/2512.08296,external,arxiv.org,ok,200,https://arxiv.org/abs/2512.08296,https://arxiv.org/abs/2512.08296,text/html; charset=utf-8,[2512.08296] Towards a Science of Scaling Agent Systems,"Agents, language model-based systems capable of reasoning, planning, and acting are widely adopted in real-world tasks, yet how their performance changes as these systems scale across key dimensions remains underexplored. We introduce quantitative scaling principles for agent systems as a predictive model, capturing how performance varies with coordination, model capability, and measurable system and task factors. Across 260 configurations spanning six agentic benchmarks, five canonical architectures (Single-Agent and four Multi-Agent: Independent, Centralized, Decentralized, Hybrid), and three LLM families, we perform controlled evaluations, standardizing tools, prompts, and compute to isolate architectural effects. The resulting model achieves a cross-validated R^2=0.373 across all six benchmarks (R^2=0.413 with a task-grounded capability metric). We identify a robust capability-saturation effect and additional patterns: (1) a coordination yields diminishing returns once single-agent baselines exceed certain performance; (2) tool-heavy tasks appear to incur multi-agent overhead; and (3) architectures without centralized verification tend to propagate errors more than those with centralized coordination. Relative performance change compared to single-agent baseline ranges from +80.8% on decomposable financial reasoning to -70.0% on sequential planning, demonstrating that architecture-task alignment determines collaborative success. The framework identifies the best-performing architecture for 87% of held-out configurations and shows consistent relative architecture preferences on unseen frontier models. Agent effectiveness depends on alignment between coordination and task structure, and that mismatched coordination degrades the performance.",Yubin Kim; Ken Gu; Chanwoo Park; Chunjong Park; Samuel Schmidgall; A. Ali Heydari; Yao Yan; Zhihan Zhang; Yuchen Zhuang; Yun Liu; Mark Malhotra; Paul Pu Liang; Hae Won Park; Yuzhe Yang; Xuhai Xu; Yilun Du; Shwetak Patel; Tim Althoff; Daniel McDuff; Xin Liu,2025-12-09,2025,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2512.08296,,2026-07-18T08:16:45+00:00
ale-0453,SWE-bench,https://www.swebench.com/,external,www.swebench.com,ok,200,https://www.swebench.com/,https://www.swebench.com/,text/html; charset=utf-8,SWE-bench Leaderboards,,,,,,swebench.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0454,SWE-bench: Can Language Models Resolve Real-World GitHub Issues?,https://arxiv.org/abs/2310.06770,external,arxiv.org,ok,200,https://arxiv.org/abs/2310.06770,https://proceedings.iclr.cc/paper_files/paper/2024/hash/edac78c3e300629acfe6cbe9ca88fb84-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0455,SWE-bench Goes Live,https://arxiv.org/abs/2505.23419,external,arxiv.org,ok,200,https://arxiv.org/abs/2505.23419,https://proceedings.neurips.cc/paper_files/paper/2025/hash/d83c4a745789690f82e86d0ef752ae7c-Abstract-Datasets_and_Benchmarks_Track.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0456,Terminal-Bench,https://www.tbench.ai/,external,www.tbench.ai,ok,200,https://www.tbench.ai/,https://www.tbench.ai/,text/html; charset=utf-8,Terminal-Bench,A benchmark for terminal agents,,,,,Terminal-Bench,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0457,Terminal-Bench repository,https://github.com/harbor-framework/terminal-bench,external,github.com,ok,200,https://github.com/harbor-framework/terminal-bench,https://github.com/harbor-framework/terminal-bench,text/html; charset=utf-8,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,2461,558,318,A benchmark for LLMs on complicated tasks in the terminal,Apache-2.0,2025-01-17T22:34:26Z,2026-07-18T01:43:52Z,,,2026-07-18T08:16:45+00:00
ale-0458,AgentBench,https://arxiv.org/abs/2308.03688,external,arxiv.org,ok,200,https://arxiv.org/abs/2308.03688,https://proceedings.iclr.cc/paper_files/paper/2024/hash/e9df36b21ff4ee211a8b71ee8b7e9f57-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0459,WebArena,https://arxiv.org/abs/2307.13854,external,arxiv.org,ok,200,https://arxiv.org/abs/2307.13854,https://proceedings.iclr.cc/paper_files/paper/2024/hash/4410c0711e9154a7a2d26f9b3816d1ef-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0460,OSWorld,https://arxiv.org/abs/2404.07972,external,arxiv.org,ok,200,https://arxiv.org/abs/2404.07972,https://proceedings.neurips.cc/paper_files/paper/2024/hash/5d413e48f84dc61244b6be550f1cd8f5-Abstract-Datasets_and_Benchmarks_Track.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0461,ToolBench,https://arxiv.org/abs/2307.16789,external,arxiv.org,ok,200,https://arxiv.org/abs/2307.16789,https://proceedings.iclr.cc/paper_files/paper/2024/hash/28e50ee5b72e90b50e7196fde8ea260e-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0462,GAIA,https://arxiv.org/abs/2311.12983,external,arxiv.org,ok,200,https://arxiv.org/abs/2311.12983,https://arxiv.org/abs/2311.12983,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0463,Tau-bench,https://arxiv.org/abs/2406.12045,external,arxiv.org,ok,200,https://arxiv.org/abs/2406.12045,https://arxiv.org/abs/2406.12045,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0464,VisualWebArena,https://arxiv.org/abs/2401.13649,external,arxiv.org,ok,200,https://arxiv.org/abs/2401.13649,https://aclanthology.org/2024.acl-long.50/,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0465,AppWorld,https://arxiv.org/abs/2407.18901,external,arxiv.org,ok,200,https://arxiv.org/abs/2407.18901,https://aclanthology.org/2024.acl-long.850/,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0466,Vending-Bench,https://arxiv.org/abs/2502.15840,external,arxiv.org,ok,200,https://arxiv.org/abs/2502.15840,https://arxiv.org/abs/2502.15840,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0467,Vending-Bench leaderboard,https://andonlabs.com/evals/vending-bench,external,andonlabs.com,ok,200,https://andonlabs.com/evals/vending-bench,https://andonlabs.com/evals/vending-bench,text/html; charset=UTF-8,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-18T08:16:45+00:00
ale-0468,SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios,https://arxiv.org/abs/2512.18470,external,arxiv.org,ok,200,https://arxiv.org/abs/2512.18470,https://arxiv.org/abs/2512.18470,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0469,EvoSkills: Self-Evolving Agent Skills via Co-Evolutionary Verification,https://arxiv.org/abs/2604.01687,external,arxiv.org,ok,200,https://arxiv.org/abs/2604.01687,https://arxiv.org/abs/2604.01687,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0470,SaaSBench: Coding Agents in Long-Horizon Enterprise SaaS Engineering,https://arxiv.org/abs/2605.17526,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.17526,https://arxiv.org/abs/2605.17526,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0471,RoadmapBench: Evaluating Long-Horizon Agentic Software Development Across Version Upgrades,https://arxiv.org/abs/2605.15846,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.15846,https://arxiv.org/abs/2605.15846,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0472,RefactorBench: Evaluating Stateful Reasoning in Language Agents Through Code,https://arxiv.org/abs/2503.07832,external,arxiv.org,ok,200,https://arxiv.org/abs/2503.07832,https://proceedings.iclr.cc/paper_files/paper/2025/hash/6b44ee74539ea77d6a0d50d468724371-Abstract-Conference.html,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0473,RigorBench: Benchmarking Engineering Process Discipline in Autonomous AI Coding Agents,https://arxiv.org/abs/2606.22678,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.22678,https://arxiv.org/abs/2606.22678,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0474,SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long-Horizon Iterative Tasks,https://arxiv.org/abs/2603.24755,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.24755,https://arxiv.org/abs/2603.24755,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0475,LongCLI-Bench: A Preliminary Benchmark for Long-horizon Agentic Programming in Command-Line Interfaces,https://arxiv.org/abs/2602.14337,external,arxiv.org,ok,200,https://arxiv.org/abs/2602.14337,https://aclanthology.org/2026.findings-acl.1497/,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0476,Can LLM-as-a-Judge Reliably Verify Rubrics in Agentic Scenarios?,https://arxiv.org/abs/2606.29920,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.29920,https://arxiv.org/abs/2606.29920,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0477,SentinelBench: A Benchmark for Long-Running Monitoring Agents,https://arxiv.org/abs/2606.05342,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.05342,https://arxiv.org/abs/2606.05342,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0478,SWE-Together: Evaluating Coding Agents in Interactive User Sessions,https://arxiv.org/abs/2606.29957,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.29957,https://arxiv.org/abs/2606.29957,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0479,The Long-Horizon Task Mirage? Diagnosing Where and Why Agentic Systems Break,https://arxiv.org/abs/2604.11978,external,arxiv.org,ok,200,https://arxiv.org/abs/2604.11978,https://arxiv.org/abs/2604.11978,text/html; charset=utf-8,[2604.11978] The Long-Horizon Task Mirage? Diagnosing Where and Why Agentic Systems Break,"Large language model (LLM) agents perform strongly on short- and mid-horizon tasks, but often break down on long-horizon tasks that require extended, interdependent action sequences. Despite rapid progress in agentic systems, these long-horizon failures remain poorly characterized, hindering principled diagnosis and comparison across domains. To address this gap, we introduce HORIZON, an initial cross-domain diagnostic benchmark for systematically constructing tasks and analyzing long-horizon failure behaviors in LLM-based agents. Using HORIZON, we evaluate state-of-the-art (SOTA) agents from multiple model families (GPT-5 variants and Claude models), collecting 3100+ trajectories across four representative agentic domains to study horizon-dependent degradation patterns. We further propose a trajectory-grounded LLM-as-a-Judge pipeline for scalable and reproducible failure attribution, and validate it with human annotation on trajectories, achieving strong agreement (inter-annotator \kappa=0.61; human-judge \kappa=0.84). Our findings offer an initial methodological step toward systematic, cross-domain analysis of long-horizon agent failures and offer practical guidance for building more reliable long-horizon agents. We release our project website at \href{https://xwang2775.github.io/horizon-leaderboard/}{HORIZON Leaderboard} and welcome contributions from the community.",Xinyu Jessica Wang; Haoyue Bai; Yiyou Sun; Haorui Wang; Shuibai Zhang; Wenjie Hu; Mya Schroder; Bilge Mutlu; Dawn Song; Robert D Nowak,2026-04-13,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2604.11978,,2026-07-18T08:16:45+00:00
ale-0480,Beyond pass@1: A Reliability Science Framework for Long-Horizon LLM Agents,https://arxiv.org/abs/2603.29231,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.29231,https://arxiv.org/abs/2603.29231,text/html; charset=utf-8,[2603.29231] Beyond pass@1: A Reliability Science Framework for Long-Horizon LLM Agents,"Existing benchmarks measure capability -- whether a model succeeds on a single attempt -- but production deployments require reliability -- consistent success across repeated attempts on tasks of varying duration. We show these properties diverge systematically as task duration grows, and that pass@1 on short tasks is structurally blind to this divergence. We introduce a reliability science framework for long-horizon LLM agents with four metrics: Reliability Decay Curve (RDC), Variance Amplification Factor (VAF), Graceful Degradation Score (GDS), and Meltdown Onset Point (MOP). We evaluate 10 models across 23,392 episodes on a 396-task benchmark spanning four duration buckets and three domains. Key findings: (1) reliability decay is domain-stratified -- SE GDS drops from 0.90 to 0.44 while document processing is nearly flat (0.74 to 0.71); (2) VAF bifurcates by capability tier -- high VAF is a capability signature, not an instability signal; (3) capability and reliability rankings diverge substantially, with multi-rank inversions at long horizons; (4) frontier models have the highest meltdown rates (up to 19%) because they attempt ambitious multi-step strategies that sometimes spiral; and (5) memory scaffolds universally hurt long-horizon performance across all 10 models. These results motivate reliability as a first-class evaluation dimension alongside capability.",Aaditya Khanal; Yangyang Tao; Junxiu Zhou,2026-03-31,2026,arXiv,arXiv,,"23 pages, 4 figures",cs.AI,arxiv-api,,,,,,,,,2603.29231,,2026-07-18T08:16:45+00:00
ale-0481,SEAGym: An Evaluation Environment for Self-Evolving LLM Agents,https://arxiv.org/abs/2606.17546,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.17546,https://arxiv.org/abs/2606.17546,text/html; charset=utf-8,[2606.17546] SEAGym: An Evaluation Environment for Self-Evolving LLM Agents,"Self-evolving LLM-based agents improve mainly by changing their agent harness: the structured execution layer around a base model, including prompts, memory, tools, middleware, runtime state, and the model-tool interaction loop. Existing evaluations often reduce this process to isolated task scores or a single sequential curve, obscuring whether an update produces reusable improvement, overfits recent tasks, increases cost, or harms older behavior. We introduce SEAGym, an evaluation environment for measuring agent harness updates across training, validation, test, replay, and cost records. SEAGym turns Harbor-compatible benchmarks into dynamic self-evolution task sources with train batches, frozen update-validation, held-out ID and OOD transfer views, replay diagnostics, and saved snapshot and metric records. Instantiating SEAGym on Terminal-Bench 2.0 and HLE, we compare ACE, TF-GRPO, and AHE under a shared epoch/batch protocol. The results show that these evaluation views provide complementary signals about the evolution process: frequent updates may fail to improve held-out performance, useful intermediate snapshots may collapse later, and source diversity and model backend can affect harness reliability.",Congjie Zheng; Chuanyi Xue; Bin Liang; Jun Yang; Changshui Zhang,2026-06-16,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2606.17546,,2026-07-18T08:16:45+00:00
ale-0482,EvoCode-Bench: Evaluating Coding Agents in Multi-Turn Iterative Interactions,https://arxiv.org/abs/2605.24110,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.24110,https://arxiv.org/abs/2605.24110,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0483,On the Reliability of Computer Use Agents,https://arxiv.org/abs/2604.17849,external,arxiv.org,ok,200,https://arxiv.org/abs/2604.17849,https://arxiv.org/abs/2604.17849,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0484,AgentLens: Revealing the Lucky Pass Problem in SWE-Agent Evaluation,https://arxiv.org/abs/2605.12925,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.12925,https://arxiv.org/abs/2605.12925,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0485,ORLoopBench: Solver-in-the-Loop Benchmarks for Self-Correction,https://arxiv.org/abs/2601.21008,external,arxiv.org,ok,200,https://arxiv.org/abs/2601.21008,https://openreview.net/pdf/16a0193aa4e71ffe6c921ac0081a66b525eea017.pdf,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0486,LongDS-Bench: On the Failure of Long-Horizon Agentic Data Analysis,https://arxiv.org/abs/2605.30434,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.30434,https://arxiv.org/abs/2605.30434,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0487,MemoryArena: Benchmarking Agent Memory in Interdependent Multi-Session Agentic Tasks,https://arxiv.org/abs/2602.16313,external,arxiv.org,ok,200,https://arxiv.org/abs/2602.16313,https://arxiv.org/abs/2602.16313,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0488,Momento: Evaluating Persistent Memory and Reasoning with Multi-Session Agentic Conversations,https://arxiv.org/abs/2606.00832,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.00832,https://arxiv.org/abs/2606.00832,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0489,π-Bench: Evaluating Proactive Personal Assistant Agents in Long-Horizon Workflows,https://arxiv.org/abs/2605.14678,external,arxiv.org,ok,200,https://arxiv.org/abs/2605.14678,https://arxiv.org/abs/2605.14678,text/html; charset=utf-8,[2605.14678] $π$-Bench: Evaluating Proactive Personal Assistant Agents in Long-Horizon Workflows,"The rise of personal assistant agents, e.g., OpenClaw, highlights the growing potential of large language models to support users across everyday life and work. A core challenge in these settings is proactive assistance, since users often begin with underspecified requests and leave important needs, constraints, or preferences unstated. However, existing benchmarks rarely evaluate whether agents can identify and act on such hidden intents before they are explicitly stated, especially in sustained multi-turn interactions where user needs emerge gradually. To address this gap, we introduce $\pi$-Bench, a benchmark for proactive assistance comprising 100 multi-turn tasks across 5 domain-specific user personas. By incorporating hidden user intents, inter-task dependencies, and cross-session continuity, $\pi$-Bench evaluates agents' ability to anticipate and address user needs over extended interactions, jointly measuring proactivity and task completion in long-horizon trajectories that better reflect real-world use. Experiments show (1) proactive assistance remains challenging, (2) a clear distinction between task completion and proactivity, and (3) the value of prior interaction for proactive intent resolution in later tasks.",Haoran Zhang; Luxin Xu; Zhilin Wang; Runquan Gui; Shunkai Zhang; Haodi Lei; Zihao He; Bingsu He; Chicheng Qin; Tong Zhu; Xiaoye Qu; Yang Yang; Yu Cheng; Yafu Li,2026-05-14,2026,arXiv,arXiv,,44 pages,cs.AI,arxiv-api,,,,,,,,,2605.14678,,2026-07-18T08:16:45+00:00
ale-0490,Can LLM Agents Be CFOs? Benchmarking Long-Horizon Resource Allocation,https://arxiv.org/abs/2603.23638,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.23638,https://arxiv.org/abs/2603.23638,text/html; charset=utf-8,[2603.23638] Can LLM Agents Be CFOs? Benchmarking Long-Horizon Resource Allocation in an Uncertain Enterprise Environment,"Large language model (LLM) agents are increasingly tested on complex tasks, but their ability to allocate scarce resources over long horizons remains unclear. Unlike reactive tasks with immediate feedback, this setting requires agents to make binding commitments under partial observability, delayed consequences, hard resource budgets, and shifting dynamics. We introduce EnterpriseArena, a 132-month CFO simulator that evaluates long-horizon resource allocation under uncertainty in a FinTech lending firm. Agents must manage liquidity, close books, gather costly signals, and request equity or debt financing across changing macroeconomic regimes. The simulator is built from transformed firm-level financial data, anonymized business documents, decade-scale macroeconomic and industry signals, and expert-validated operating rules. Experiments across 23 LLMs and four agent frameworks show that current agents remain far from robust: only 15.4% of trials survive the full horizon, larger models do not reliably outperform smaller ones, and failures cascade across observation, action timing, and capital sizing. These findings establish long-horizon resource allocation under uncertainty as a distinct capability gap for LLM agents.",Yi Han; Yan Wang; Lingfei Qian; Haohang Li; Yupeng Cao; Yueru He; Xueqing Peng; Nanhan Shen; Yitao Xu; Yankai Chen; Dongji Feng; Jimin Huang; Xue Liu; Jian-Yun Nie; Sophia Ananiadou,2026-03-24,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2603.23638,,2026-07-18T08:16:45+00:00
ale-0491,EvoAgentBench: Benchmarking Agent Self-Evolution via Ability Transfer,https://arxiv.org/abs/2607.05202,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.05202,https://arxiv.org/abs/2607.05202,text/html; charset=utf-8,[2607.05202] EvoAgentBench: Benchmarking Agent Self-Evolution via Ability Transfer,"Agent self-evolution in long-horizon LLM systems is largely procedural: useful experience is not merely stored information, but reusable procedures for searching, debugging, and verification. Yet current evaluations do not isolate this form of transfer. Agent benchmarks test single-episode task solving; memory benchmarks target information retention rather than procedural reuse. We introduce EvoAgentBench, a benchmark for agent self-evolution via Ability-guided transfer across four agentic domains: web research, algorithmic reasoning, software engineering, and knowledge work. EvoAgentBench extracts trace-grounded Abilities from agent executions, canonicalizes them into operational units, and builds domain-specific Ability Graphs linking tasks that share procedural overlap. By design, every test task is backed by verified training-side Ability support. Across a 528/267 train/test split, two scaffolds, and three backbones, curated Ability content transfers reliably across model families, but no current automatic method sustains positive gain in all settings. EvoAgentBench shifts self-evolution evaluation from aggregate accuracy comparison to fine-grained diagnosis of experience encoding, routing, and uptake. The benchmark is publicly available at https://huggingface.co/datasets/EverMind-AI/EvoAgentBench.",Xingze Gao; Chuanrui Hu; Hongda Chen; Pengfei Yao; Zhao Wang; Yi Bai; Zhengwei Wu; Yunyun Han; Xiaofeng Cong; Jie Gui; Yafeng Deng; Teng Li,2026-07-06,2026,arXiv,arXiv,,"15 pages, 2 figures, 8 tables",cs.AI,arxiv-api,,,,,,,,,2607.05202,,2026-07-18T08:16:45+00:00
ale-0492,AgenticSTS: A Bounded-Memory Testbed for Long-Horizon LLM Agents,https://arxiv.org/abs/2607.02255,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.02255,https://arxiv.org/abs/2607.02255,text/html; charset=utf-8,[2607.02255] AgenticSTS: A Bounded-Memory Testbed for Long-Horizon LLM Agents,"Memory for a long-horizon LLM agent is a contract about what each future decision is allowed to see. The simplest contract appends past observations, tool calls, and reflections to every prompt, which makes prior context easy to access but also turns it into a jumbled mixture in which the effect of any single memory component is hard to isolate. We introduce and instrument an alternative bounded contract: every decision is made from a fresh user message assembled by typed retrieval, with no raw cross-decision transcript appended. The prompt thus stays bounded across runs of any length, and any single layer can be ablated in isolation. We instantiate the contract in Slay the Spire 2, a closed-rule stochastic deck-building game whose runs require hundreds of tactical and strategic decisions. A public online benchmark of frontier LLMs on the same game reports zero wins at the lowest difficulty across five configurations, and the developer-reported human win rate at the same difficulty is 16%; the task is hard but not saturated. Within our harness, a fixed-A0 ablation shows the largest observed difference when triggered strategic skills are enabled: the no-store baseline wins 3/10 games and adding the skill layer 6/10. At this sample size the comparison is directional rather than statistically decisive (Fisher exact p\approx0.37); a cross-backbone probe and public accumulating-context baselines are reported as operational comparisons rather than controlled tests of the contract variable itself. We release a reproducible testbed: 298 completed trajectories with condition tags, frozen memory/skill snapshots, prompt records, and analysis scripts -- an agent design and a validated, reusable methodology for studying how explicit memory layers shape long-horizon LLM-agent decisions.",Xiangchen Cheng; Yunwei Jiang; Jianwen Sun; Zizhen Li; Chuanhao Li; Xiangcheng Cao; Yihao Liu; Fanrui Zhang; Li Jin; Kaipeng Zhang,2026-07-02,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.02255,,2026-07-18T08:16:45+00:00
ale-0493,Is Three the Magic Number? An Empirical Evaluation of LLM-Based Repair Loops,https://arxiv.org/abs/2607.05197,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.05197,https://arxiv.org/abs/2607.05197,text/html; charset=utf-8,[2607.05197] Is Three the Magic Number? An Empirical Evaluation of LLM-Based Repair Loops,"Iterative repair loops have become a core design pattern in LLM-based software engineering systems. These workflows repeatedly generate, validate, and repair artifacts using feedback such as compiler errors or test failures. Despite their widespread use, the impact of repair-loop iteration limits remains poorly understood, as most prior work adopts fixed, often arbitrary, repair budgets. We study repair-loop effectiveness across multiple software engineering tasks, including code generation, test generation, and code translation. Across several representative workflows, datasets, and contemporary low-cost LLMs, we observe a consistent pattern of diminishing returns: the first three to four repair iterations account for most achievable gains, while later iterations contribute only marginal improvements. We further find that repair behavior is influenced more strongly by workflow orchestration and feedback design than by the underlying model itself. These results suggest that repair budgets should be treated as an explicit experimental variable, as they directly affect evaluation outcomes, computational cost, runtime, and reproducibility in LLM-based software engineering research.",Tobias Kiecker; Eik Reichmann; Hosung Kang; Gabin An; Lars Grunske,2026-07-06,2026,arXiv,arXiv,,"4 Pages (+1 for references), NIER Paper",cs.SE,arxiv-api,,,,,,,,,2607.05197,,2026-07-18T08:16:45+00:00
ale-0494,"DeepSWE: Measuring Frontier Coding Agents on Original, Long-Horizon Engineering Tasks",https://arxiv.org/abs/2607.07946,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07946,https://arxiv.org/abs/2607.07946,text/html; charset=utf-8,"[2607.07946] DeepSWE: Measuring Frontier Coding Agents on Original, Long-Horizon Engineering Tasks","DeepSWE is a benchmark of 113 original, long-horizon software engineering tasks for evaluating coding agents. Most public agentic coding benchmarks follow SWE-bench in mining merged fixes from public GitHub repositories, which creates two problems: the fixes and their discussion were likely seen during pretraining, so a high score can reflect recall rather than problem-solving; and each task is graded by the tests that shipped with its merged fix, which were written to confirm one specific fix rather than grade an arbitrary solution, so they can fail a correct alternative or pass an incomplete one. DeepSWE avoids both. Its tasks are written from scratch across 91 active open-source repositories and five languages and are never contributed back upstream, so their reference solutions stay out of the public record that model training scrapes; and each task is graded by a hand-written verifier that checks the requested functionality and accepts any implementation that provides it. When an independent LLM judge re-reviews graded runs, it disagrees with DeepSWE's verifier about an order of magnitude less often than with SWE-Bench Pro's inherited tests (1.4% versus 32.4%). Despite being about half the length of SWE-Bench Pro's prompts, DeepSWE's prompts describe tasks whose reference solutions touch 5.5x more code, and the benchmark separates frontier agents across a wider score band than the leaderboards on which they otherwise cluster. We release the benchmark, its verifiers, and the full record of evaluation trajectories.",Wenqi Huang; Charley Lee; Leonard Tng; Serena Ge,2026-07-08,2026,arXiv,arXiv,,"32 pages, 10 figures. Code and data: https://github.com/datacurve-ai/deep-swe ; https://deepswe.datacurve.ai/",cs.SE,arxiv-api,,,,,,,,,2607.07946,,2026-07-18T08:16:45+00:00
ale-0495,PERFOPT-Bench: Evaluating Coding Agents on Software Performance Optimization,https://arxiv.org/abs/2607.07744,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07744,https://arxiv.org/abs/2607.07744,text/html; charset=utf-8,[2607.07744] PERFOPT-Bench: Evaluating Coding Agents on Software Performance Optimization,"Coding-agent benchmarks have largely measured whether agents can produce functionally correct patches, but production software also demands measurable speedups on real execution targets. Performance optimization is a distinct agentic task: agents must profile executions, diagnose cross-layer bottlenecks, edit code without breaking correctness, and verify that gains are reproducible rather than measurement artifacts. We introduce PERFOPT-Bench, a benchmark for evaluating this full performance-engineering loop. Each task provides a correct but deliberately suboptimal codebase and asks the agent to improve a target performance metric; scoring requires hidden correctness tests, verified-speedup measurement, and trajectory-level audit. We evaluate 7 agent stacks with different LLMs and agent frameworks on 7 long-horizon optimization tasks. The results show that optimization performance is workload-dependent rather than determined by model identity alone: no single stack dominates, and changing the agent framework can materially change the same LLM's per-task speedup profile. We further find that raw speedup is unsafe as a benchmark score, since some large gains arise from benchmark-specific shortcut exploitation; an exploratory relay pilot suggests that restarting from an externalized optimization summary can recover additional headroom after an initial session stops. The benchmark and our evaluation are available at: https://anonymous.4open.science/r/Dataset-D3CC.",Yingyun Cui; Yi Xie; Piaohong Wang; Jiawei Ma; Bo Liu; Liangliang Cao,2026-07-08,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,,,2607.07744,,2026-07-18T08:16:45+00:00
ale-0496,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,ok,200,https://www.databricks.com/blog/benchmarking-coding-agents-databricks-multi-million-line-codebase,https://www.databricks.com/blog/benchmarking-coding-agents-databricks-multi-million-line-codebase,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0497,UniClawBench: A Universal Benchmark for Proactive Agents on Real-World Tasks,https://arxiv.org/abs/2607.08768,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08768,https://arxiv.org/abs/2607.08768,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0498,SLBench: Evaluating How LLM Agents Follow Logical Relations in Skills,https://arxiv.org/abs/2607.09016,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.09016,https://arxiv.org/abs/2607.09016,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0499,SWE-Milestone: Evaluating AI Agents on Continuous Software Evolution,https://arxiv.org/abs/2603.13428,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.13428,https://arxiv.org/abs/2603.13428,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0500,AgentAbstain: Do LLM Agents Know When Not to Act?,https://arxiv.org/abs/2607.10059,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.10059,https://arxiv.org/abs/2607.10059,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0501,"Agents Don't Just Agree, They Remember: Benchmarking Persistent Sycophancy",https://arxiv.org/abs/2607.10526,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.10526,https://arxiv.org/abs/2607.10526,text/html; charset=utf-8,"[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-18T08:16:45+00:00
ale-0502,Set-shifting Behavioral Test for Harnessed Agents,https://arxiv.org/abs/2607.13396,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.13396,https://arxiv.org/abs/2607.13396,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0503,MCPEvol-Bench: Benchmarking LLM Agent Performance Across Dynamic Evolutions of MCP Servers,https://arxiv.org/abs/2607.14642,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14642,https://arxiv.org/abs/2607.14642,text/html; charset=utf-8,[2607.14642] MCPEvol-Bench: Benchmarking LLM Agent Performance Across Dynamic Evolutions of MCP Servers,"As Model Context Protocol (MCP) servers emerge as the core infrastructure for connecting LLMs with external tools, existing benchmarks leverage real-world MCP servers to evaluate LLM agents' tool-using capabilities. However, these benchmarks overlook the continuous evolution of tool interfaces and functionalities within MCP servers, resulting in flawed assessments that fail to capture the agent's adaptability in changing tool landscapes. To bridge this gap, we introduce \textbf{MCPEvol-Bench}, a novel benchmark for evaluating the task-solving capabilities of LLM agents under dynamic toolset evolution. Inspired by large-scale empirical study, we propose 11 mutation operators to simulate realistic tool evolution within 123 MCP servers. We benchmark 12 state-of-the-art LLMs on multiple versions of MCP servers, revealing that even frontier models struggle to adapt to evolving tools. For instance, GPT-5.4 and Claude-Sonnet-4-6 exhibit performance declines of 13.7\% and 14.4\% in evolved MCP servers, respectively, accompanied by substantial increases in planning and reasoning errors. These findings highlight the vulnerability of LLM-driven workflows, establishing MCPEvol-Bench as a standard for evaluating agent adaptability in dynamic tool environments.",Huanxi Liu; Kun Hu; Jiaqi Liao; Qiang Wang; Pengfei Qian; YuanZhao Zhai; Dawei Feng; Bo Ding; Huaimin Wang,2026-07-16,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.14642,,2026-07-18T08:16:45+00:00
ale-0504,MM-IssueLoc: A Controlled Benchmark for Evaluating Visual Evidence in Multimodal Repository-Level Issue Localization,https://arxiv.org/abs/2607.15205,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.15205,https://arxiv.org/abs/2607.15205,text/html; charset=utf-8,[2607.15205] MM-IssueLoc: A Controlled Benchmark for Evaluating Visual Evidence in Multimodal Repository-Level Issue Localization,"Real repository issues routinely include visual evidence such as screenshots, error dialogs, rendered UI states, and logs, yet repository-level issue localization is evaluated mostly as a text-only task. Existing multimodal SE benchmarks evaluate end-to-end repair, entangling localization with patch synthesis and obscuring whether visual input helped, hurt, or was ignored. We introduce \textbf{MM-IssueLoc}, a controlled benchmark and evaluation protocol for repository-level localization with visual evidence. MM-IssueLoc contains 652 issue-PR instances across 23 languages, with annotations for 7 image categories and 4 relevance levels. It provides file-level and function-level gold labels, paired text-only and with-image evaluation, and VCE-based diagnostics that convert images into structured textual evidence. We evaluate LLM-based and retrieval-based systems, including MM-IssueLoc-VL-Emb as a controlled multimodal retriever. Results show that existing systems remain far from reliable multimodal repository localization: the strongest agent reaches 38.96 file Acc@5 and 22.45 function Acc@10, while the strongest retriever reaches 33.86 function Acc@10. Cross-benchmark comparisons show that high localization scores on text-dominant SWE benchmarks do not transfer cleanly to multimodal issue localization. MM-IssueLoc turns visual evidence into an explicit evaluation variable, enabling future work to test whether systems improve by using visual evidence for localization, rather than by relying on text-only cues or downstream patch-generation effects.",Shaoxiong Zhan; Shi Hu; Boyu Feng; Hai Lin; Andrew Gong; Zhengda Zhou; Jiaying Zhou; Yunyun Hou; Hao Su; Hai-Tao Zheng,2026-07-16,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,,,2607.15205,,2026-07-18T08:16:45+00:00
ale-0505,MobileWorld: Benchmarking Autonomous Mobile Agents in Agent-User Interaction and MCP-Augmented Tasks,https://aclanthology.org/2026.acl-long.278/,external,aclanthology.org,ok,200,https://aclanthology.org/2026.acl-long.278/,https://aclanthology.org/2026.acl-long.278/,text/html; charset=utf-8,MobileWorld: Benchmarking Autonomous Mobile Agents in Agent-User Interactive and MCP-Augmented Environments - ACL Anthology,"Quyu Kong, Xu Zhang, Zhenyu Yang, Nolan Gao, Chen Liu, Panrong Tong, Chenglin Cai, Hanzhang Zhou, Jianan Zhang, Liangyu Chen, Zhidan Liu, Steven Hoi, Yue Wang. Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 2026.",Quyu Kong; Xu Zhang; Zhenyu Yang; Nolan Gao; Chen Liu; Panrong Tong; Chenglin Cai; Hanzhang Zhou; Jianan Zhang; Liangyu Chen; Zhidan Liu; Steven Hoi; Yue Wang,2026,2026,Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers),ACL Anthology,10.18653/v1/2026.acl-long.278,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0506,AGENCYBENCH: Benchmarking the Frontiers of Autonomous Agents,https://aclanthology.org/2026.acl-long.337/,external,aclanthology.org,ok,200,https://aclanthology.org/2026.acl-long.337/,https://aclanthology.org/2026.acl-long.337/,text/html; charset=utf-8,AgencyBench: Benchmarking the Frontiers of Autonomous Agents in 1M-Token Real-World Contexts - ACL Anthology,"Keyu Li, Junhao Shi, Yang Xiao, Mohan Jiang, Jie Sun, Yunze Wu, Dayuan Fu, Shijie Xia, Xiaojie Cai, Tianze Xu, Weiye Si, Wenjie Li, Dequan Wang, Pengfei Liu. Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 2026.",Keyu Li; Junhao Shi; Yang Xiao; Mohan Jiang; Jie Sun; Yunze Wu; Dayuan Fu; Shijie Xia; Xiaojie Cai; Tianze Xu; Weiye Si; Wenjie Li; Dequan Wang; Pengfei Liu,2026,2026,Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers),ACL Anthology,10.18653/v1/2026.acl-long.337,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0507,Agentic Engineering: The Agent Loop,https://junpingyi.com/books/agentic-engineering/agent-loop/,external,junpingyi.com,ok,200,https://junpingyi.com/books/agentic-engineering/agent-loop/,https://junpingyi.com/books/agentic-engineering/agent-loop/,text/html,Chapter 1: The Agent Loop — Agentic Engineering: How to Build AI Agents Like Claude Code,Chapter 1: The Agent Loop from Agentic Engineering: How to Build AI Agents Like Claude Code,,,,,junpingyi.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0508,"The agent loop: ReAct, plan-and-execute, reflection",https://www.kunwar.page/chapter/067-the-agent-loop-react-plan-and-execute-reflection,external,www.kunwar.page,ok,200,https://www.kunwar.page/chapter/067-the-agent-loop-react-plan-and-execute-reflection,https://www.kunwar.page/chapter/067-the-agent-loop-react-plan-and-execute-reflection,text/html; charset=utf-8,"Chapter 67: The agent loop: ReAct, plan-and-execute, reflection — The Holy Grail Basic agent loop: generate, check for tool calls, execute tools and loop back, or return final answer on no tool call. ReAct interleaves Thought, Action, and Observation triplets; each Thought improves the next Action choice by externalizing reasoning. Agent cost vs single-shot: one LLM call versus 5-12 interleaved LLM and tool calls, showing the 10x cost and latency multiplier.",An agent is a loop of `model.generate()` calls with tool calls in between. The loop is the entire pattern,,,,,kunwar.page,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0509,How to Build an Agent,https://ampcode.com/how-to-build-an-agent,external,ampcode.com,ok,200,https://ampcode.com/notes/how-to-build-an-agent,https://ampcode.com/notes/how-to-build-an-agent,text/html,How to Build an Agent - Amp,"Building a fully functional, code-editing agent in less than 400 lines.",,,,,ampcode.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0510,Agentic Coding Recommendations,https://lucumr.pocoo.org/2025/6/12/agentic-coding/,external,lucumr.pocoo.org,ok,200,https://lucumr.pocoo.org/2025/6/12/agentic-coding/,https://lucumr.pocoo.org/2025/6/12/agentic-coding/,text/html; charset=utf-8,Agentic Coding Recommendations | Armin Ronacher's Thoughts and Writings,Current recommendations of agentic coding.,,2025-06-12,2025,,Armin Ronacher's Thoughts and Writings,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0511,Coding Agents 101: The Art of Actually Getting Things Done,https://devin.ai/agents101,external,devin.ai,ok,200,https://devin.ai/agents101,https://devin.ai/agents101,text/html; charset=utf-8,Coding Agents 101: The Art of Actually Getting Things Done,Coding Agents 101: The Art of Actually Getting Things Done,,,,,devin.ai,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0512,How Anthropic teams use Claude Code,https://claude.com/blog/how-anthropic-teams-use-claude-code,external,claude.com,ok,200,https://claude.com/blog/how-anthropic-teams-use-claude-code,https://claude.com/blog/how-anthropic-teams-use-claude-code,text/html; charset=utf-8,How Anthropic teams use Claude Code | Claude by Anthropic,Teams across Anthropic use Claude Code for everything from debugging production issues and navigating unfamiliar codebases to building custom automation tools. Here's how. ‍,,,,,Claude,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0513,How Boris Uses Claude Code,https://howborisusesclaudecode.com/,external,howborisusesclaudecode.com,ok,200,https://howborisusesclaudecode.com/,https://howborisusesclaudecode.com/,text/html; charset=UTF-8,Boris Cherny's Claude Code Tips — How He Actually Uses It (121+ Tips),"121+ tips from Boris Cherny, creator of Claude Code, on his daily workflow: CLAUDE.md, worktrees, plan mode, hooks, subagents, and more.",@CarolinaCherry,,,,How Boris Uses Claude Code,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0514,Agent of the Day: Copilot Agent PR Analysis,https://github.github.com/gh-aw/blog/2026-05-26-agent-of-the-day/,external,github.github.com,ok,200,https://github.github.com/gh-aw/blog/2026-05-26-agent-of-the-day/,https://github.github.com/gh-aw/blog/2026-05-26-agent-of-the-day/,text/html; charset=utf-8,"Agent of the Day – May 26, 2026 | GitHub Agentic Workflows",Copilot Agent PR Analysis: a daily workflow that monitors GitHub Copilot coding agent performance across pull requests,,,2026,,GitHub Agentic Workflows,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0515,"Progressive Crystallization: Turning Agent Exploration into Deterministic, Lower-Cost Workflows",https://arxiv.org/abs/2607.07052,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07052,https://arxiv.org/abs/2607.07052,text/html; charset=utf-8,"[2607.07052] Progressive Crystallization: Turning Agent Exploration into Deterministic, Lower-Cost Workflows in Production","AI agents deployed for IT operations are typically permanent cost centers because every execution requires full LLM inference, even for previously solved problems. This paper introduces progressive crystallization, a lifecycle that treats agent exploration as a discovery mechanism rather than a permanent execution model. It defines a three-stage execution taxonomy, from fully agent-orchestrated to hybrid to fully deterministic workflows, together with an evidence-based promotion mechanism that converts repeatedly validated agent behaviors into cheaper and more reproducible deterministic workflows, while automatically demoting workflows that regress. Evaluated on a production cloud networking AIOps system processing tens of thousands of incidents per month, the approach increased deterministic execution from 0% to 45% over eight months, reduced per-incident agent costs by more than 70% despite doubling incident volume, and improved safety through greater reproducibility and auditability. The paper also presents the execution taxonomy, promotion and demotion criteria, trace extraction methodology, economic model, safety considerations, and discusses limitations and threats to validity.",Arun Malik,2026-07-08,2026,arXiv,arXiv,,"Conference-style paper; 10 pages (estimated from manuscript formatting if applicable); focuses on agentic AI, AIOps, workflow automation, deterministic execution, and LLM cost optimization",cs.SE,arxiv-api,,,,,,,,,2607.07052,,2026-07-18T08:16:45+00:00
ale-0516,Tool-Making and Self-Evolving LLM Agents in Low-Latency Systems,https://arxiv.org/abs/2607.08010,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.08010,https://arxiv.org/abs/2607.08010,text/html; charset=utf-8,[2607.08010] Tool-Making and Self-Evolving LLM Agents in Low-Latency Systems,"Production LLM agents often waste latency and reliability by regenerating code for the same procedural steps on every request. We replace this inference-time coding loop with an agentic tool-making pipeline that compiles repeated SOP steps into validated, versioned tools before deployment. The tool-maker grounds synthesis in the live environment as it collects execution traces, observes backend schemas and values, generates candidate tools, and repairs them against labeled cases. At runtime, the production agent calls these tools directly and falls back to code generation only when needed. We deploy the approach in a Fulfillment Center alarm-triage system, where an agent diagnoses alarms against a 44-node SOP over heterogeneous metric backends. In production, tool calls reduce p50 latency by 42%. On 1,500 historical alarms, they reduce end-to-end error rate by up to 53% by suppressing run-to-run variance in repeated steps. Because tools return compact structured verdicts, they also enable a simpler direct-call architecture, reducing p50 latency by a further 62% in a controlled ablation. Versioned tools also improve auditability and expose specification gaps and upstream data drift. Our results show that self-evolving agents can make industrial LLM systems faster, more reliable, and easier to operate.",Kalle Kujanpää; Ning Liu; Shahnawaz Alam; Yeshwanth Reddy Sura; Tianyu Yang; Kristina Klinkner; Shervin Malmasi,2026-07-09,2026,arXiv,arXiv,,Preprint,cs.CL,arxiv-api,,,,,,,,,2607.08010,,2026-07-18T08:16:45+00:00
ale-0517,AI Loop Engineering: Build Autonomous Agents with Claude Code /goal and Routines,https://www.sabrina.dev/p/loop-engineering-claude-code-goal-routines,external,www.sabrina.dev,ok,200,https://www.sabrina.dev/p/loop-engineering-claude-code-goal-routines,https://www.sabrina.dev/p/loop-engineering-claude-code-goal-routines,text/html; charset=utf-8,AI Loop Engineering: Build Autonomous Agents with Claude Code /goal + Routines,"What loop engineering means in 2026, how to use the Claude Code /goal command, and how to build your first autonomous AI agent with a routine.",Sabrina Ramonov 🍄,,,,sabrina.dev,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0518,Agent Delivery Engineering Predictive Reliability Framework,https://arxiv.org/abs/2607.07689,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07689,https://arxiv.org/abs/2607.07689,text/html; charset=utf-8,[2607.07689] Agent Delivery Engineering Predictive Reliability Framework,"Long-horizon LLM multi-agent systems face reliability risks invisible to infrastructure monitoring. We propose the ADE Predictive Reliability Framework (ADE-PRF), enabling proactive health trajectory prediction from passive degradation detection. ADE-PRF aggregates 20 heterogeneous signals across five layers into a Trust Margin (TM) metric (39.2-point dynamic range). Triple-method parallel prediction enables 8-hour forecasts: the Exponential method achieves MAE=1.228, Direction Accuracy=76.8%, with 99.65% within +/-10-point tolerance. Production validation spans 380,227 predictions and 280,579 validations across six agent profiles over 15 continuous days, plus seven sandbox-controlled experiments. Key findings include detection of ""false prosperity"" -- degradation concealed by normal surface metrics -- and immediate TM coupling with ground-truth states upon ADE plugin integration, with 16/20 factors relying on ADE-collected data. Exponential consistently outperforms Kalman. ADE-PRF provides among the earliest reliability quantification with forward-looking warnings for production LLM agents.",Dexing Liu,2026-07-08,2026,arXiv,arXiv,,"117pages,83figures",cs.MA,arxiv-api,,,,,,,,,2607.07689,,2026-07-18T08:16:45+00:00
ale-0519,rocketplaneIO,https://github.com/olemeyer/rocketplaneIO,external,github.com,ok,200,https://github.com/olemeyer/rocketplaneIO,https://github.com/olemeyer/rocketplaneIO,text/html; charset=utf-8,"GitHub - olemeyer/rocketplaneIO: Self-hosted AI SRE for Kubernetes — zero-instrumentation eBPF observability plus a copilot that fixes issues through guardrailed, self-verifying actions. BYO-LLM, air-gapped capable. · GitHub","Self-hosted AI SRE for Kubernetes — zero-instrumentation eBPF observability plus a copilot that fixes issues through guardrailed, self-verifying actions. BYO-LLM, air-gapped capable. - olemeyer/rocketplaneIO",,2026-07-06,2026,olemeyer/rocketplaneIO,GitHub,,,,github-api,olemeyer/rocketplaneIO,141,3,0,"Self-hosted AI SRE for Kubernetes — zero-instrumentation eBPF observability plus a copilot that fixes issues through guardrailed, self-verifying actions. BYO-LLM, air-gapped capable.",Apache-2.0,2026-07-06T11:24:01Z,2026-07-15T11:30:27Z,,,2026-07-18T08:16:45+00:00
ale-0520,Migrating a Production AI Agent to GPT-5.6,https://ploy.ai/blog/migrating-a-production-ai-agent-to-gpt-5-6,external,ploy.ai,ok,200,https://ploy.ai/blog/migrating-a-production-ai-agent-to-gpt-5-6,https://ploy.ai/blog/migrating-a-production-ai-agent-to-gpt-5-6,text/html,Migrating a production AI agent to GPT-5.6 | Ploy,"For four months, no frontier model beat Claude Opus in our production evals. GPT-5.6 did. This is what we learned while migrating.",,,,,Ploy,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0521,Coding-agents can replicate scientific machine learning papers,https://arxiv.org/abs/2607.02134,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.02134,https://arxiv.org/abs/2607.02134,text/html; charset=utf-8,[2607.02134] Coding-agents can replicate scientific machine learning papers,"Scientific machine learning papers typically make computational claims, e.g., that the relative mean square error is less than 5% or that the 95% predictive credible interval covers the test data. A coding agent can be prompted to replicate those claims from paper materials alone, but the prompt does not by itself reliably preserve progress or check whether generated evidence supports the paper's claims. We introduce Paper-replication, a workflow that makes each selected paper claim a target with recorded evidence, and implement it as a coding-agent skill. The workflow makes the agent record those targets, reconstruct the paper's method, run computational experiments, link generated outputs to provenance and comparisons with the paper's claims, record where matched evidence appears in the replication report, and pass validation checks before completion. We evaluate Paper-replication on twelve independent runs across four scientific machine learning papers. All twelve workspaces pass the completion gate, and all 158 recorded targets are matched with report coverage. Even in this completed workspace state, repeated runs differ in how papers are divided into targets, in numerical fidelity to the source papers, in elapsed replication time, in the number of intermediate executions replaced before final evidence is accepted, and in the rules used to accept evidence. Paper-replication makes completion depend on workspace evidence and validation checks rather than on the agent's final message.",Atharva Hans; Ilias Bilionis,2026-07-02,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.02134,,2026-07-18T08:16:45+00:00
ale-0522,Resource entry template,templates/resource-entry.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/templates/resource-entry.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/templates/resource-entry.md,,Resource entry template,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0523,Loop pattern template,templates/loop-pattern.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/templates/loop-pattern.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/templates/loop-pattern.md,,Loop pattern template,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0524,Loop contract schema,schemas/loop-contract.schema.json,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/schemas/loop-contract.schema.json,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/schemas/loop-contract.schema.json,,Loop contract schema,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0525,Loop contract preview script,scripts/preview_loop_contract.py,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/scripts/preview_loop_contract.py,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/scripts/preview_loop_contract.py,,Loop contract preview script,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0526,Translation guide,TRANSLATIONS.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/TRANSLATIONS.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/TRANSLATIONS.md,,Translation guide,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0527,Pattern library index,patterns/README.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/README.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/README.md,,Pattern library index,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0528,Validated contract catalog,examples/README.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/README.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/README.md,,Validated contract catalog,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0529,Loop contract library,examples/README.md#contract-catalog,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/README.md#contract-catalog,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/README.md#contract-catalog,,Loop contract library,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0530,Runnable test-repair loop,examples/runnable/test-repair-loop.sh,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/runnable/test-repair-loop.sh,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/runnable/test-repair-loop.sh,,Runnable test-repair loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0531,Runnable loop guide,examples/runnable/README.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/runnable/README.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/runnable/README.md,,Runnable loop guide,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0532,Loop gallery guide,gallery/README.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/gallery/README.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/gallery/README.md,,Loop gallery guide,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0533,Loop gallery template,gallery/template.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/gallery/template.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/gallery/template.md,,Loop gallery template,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0534,PR babysitter reference loop,gallery/pr-babysitter-reference.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/gallery/pr-babysitter-reference.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/gallery/pr-babysitter-reference.md,,PR babysitter reference loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0535,CI repair reference loop,gallery/ci-repair-reference.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/gallery/ci-repair-reference.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/gallery/ci-repair-reference.md,,CI repair reference loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0536,Docs drift reference loop,gallery/docs-drift-reference.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/gallery/docs-drift-reference.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/gallery/docs-drift-reference.md,,Docs drift reference loop,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0537,Most Developers Do Not Need Agent Loops Yet,https://alphasignalai.substack.com/p/most-developers-do-not-need-agent,external,alphasignalai.substack.com,ok,200,https://alphasignalai.substack.com/p/most-developers-do-not-need-agent,https://alphasignalai.substack.com/p/most-developers-do-not-need-agent,text/html; charset=utf-8,Most Developers Do Not Need Agent Loops Yet,"The patterns were documented in 2024. Here’s who it pays off for, and the four conditions that decide.",AlphaSignal AI,,,,Substack,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0538,Engineering Agentic Systems for Reliability,https://pruningmypothos.com/systems/engineering-agentic-systems-for-reliability/,external,pruningmypothos.com,ok,200,https://pruningmypothos.com/systems/engineering-agentic-systems-for-reliability/,https://pruningmypothos.com/systems/engineering-agentic-systems-for-reliability/,text/html,Engineering Agentic Systems for Reliability | Sans Serif Systems,"A practical reliability model for agentic systems built around governed steps, verification, escalation, and observability.",Shailesh Rawat,,,,Sans Serif Systems,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0539,"Self-Correcting Agents: Reflexion, CRITIC, and ReAct Loops Compared",https://callsphere.ai/blog/self-correcting-agents-reflexion-critic-react-loops-compared-2026,external,callsphere.ai,ok,200,https://callsphere.ai/blog/self-correcting-agents-reflexion-critic-react-loops-compared-2026,https://callsphere.ai/blog/self-correcting-agents-reflexion-critic-react-loops-compared-2026,text/html; charset=utf-8,"Self-Correcting Agents: Reflexion, CRITIC, and ReAct Loops Compared | CallSphere Blog","Three self-correction patterns dominate 2026 agent design. Side-by-side analysis of where each one wins, where each one fails, and how to combine them.",CallSphere,2026-04-24,2026,,CallSphere,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0540,How to Build an AI Agent Harness: A 2026 Complete Guide,https://atlan.com/know/how-to-build-ai-agent-harness/,external,atlan.com,ok,200,https://atlan.com/know/how-to-build-ai-agent-harness/,https://atlan.com/know/how-to-build-ai-agent-harness/,text/html,How to Build an AI Agent Harness: Step-by-Step Tutorial (2026),"Most agent harnesses fail at the data layer, not the loop. Build one the right way in 10 steps, with code and a done test for each. Start at Step 0.",,,,,atlan.com,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0541,Harness Engineering vs Prompt Engineering vs Context Engineering Explained,https://medium.com/@visrow/harness-engineering-vs-prompt-engineering-vs-context-engineering-explained-0423b692c87d,external,medium.com,ok,200,https://medium.com/@visrow/harness-engineering-vs-prompt-engineering-vs-context-engineering-explained-0423b692c87d,https://medium.com/@visrow/harness-engineering-vs-prompt-engineering-vs-context-engineering-explained-0423b692c87d,text/html; charset=utf-8,"Medium Harness Engineering vs Prompt Engineering vs Context Engineering Explained | by Vishal Mysore | May, 2026 | Medium",Harness Engineering vs Prompt Engineering vs Context Engineering Explained Understanding the evolution from prompts and RAG to reliable AI agent runtime systems. Prompt Engineering tells the model …,Vishal Mysore,2026-05-19,2026,,Medium,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0542,Position: Coding Benchmarks Are Misaligned with Agentic Software Engineering,https://arxiv.org/abs/2606.17799,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.17799,https://arxiv.org/abs/2606.17799,text/html; charset=utf-8,[2606.17799] Position: Coding Benchmarks Are Misaligned with Agentic Software Engineering,"Coding agents have become a major mode of software engineering, but the benchmarks we use to compare them were designed in a pre-agent era: they collapse model, harness, and environment into a single end-to-end score, typically computed against one reference solution, with no component-level signal for iteration. We argue that current coding benchmarks are misaligned with agentic software engineering. A coding agent in practice is not a model: it is a system harness -- a composite of models, harnesses, contexts, environments, and feedback signals, any one of which can move the benchmark score by margins comparable to those between adjacent model generations. We discuss three symptoms: (i) benchmark scores conflate the model with the rest of the harness; (ii) grading against a single reference solution penalises equally valid alternatives; and (iii) the absence of signal at the level of individual harness components makes the end-to-end system score difficult to iterate on.",Maria I. Gorinova; Macey Baker; Amy Heineike; Maksim Shaposhnikov; Rob Willoughby; Dru Knox,2026-06-16,2026,arXiv,arXiv,,,cs.SE,arxiv-api,,,,,,,,,2606.17799,,2026-07-18T08:16:45+00:00
ale-0543,Understanding the Challenges in Iterative Generative Optimization with LLMs,https://arxiv.org/abs/2603.23994,external,arxiv.org,ok,200,https://arxiv.org/abs/2603.23994,https://arxiv.org/abs/2603.23994,text/html; charset=utf-8,[2603.23994] Understanding the Challenges in Iterative Generative Optimization with LLMs,"Generative optimization uses large language models (LLMs) to iteratively improve artifacts (such as code, workflows or prompts) using execution feedback. It is a promising approach to building self-improving agents, yet in practice remains brittle: despite active research, only 9% of surveyed agents used any automated optimization. We argue that this brittleness arises because, to set up a learning loop, an engineer must make ``hidden'' design choices: What can the optimizer edit and what is the ""right"" learning evidence to provide at each update? We investigate three factors that affect most applications: the starting artifact, the credit horizon for execution traces, and batching trials and errors into learning evidence. Through case studies in MLAgentBench, Atari, and BigBench Extra Hard, we find that these design decisions can determine whether generative optimization succeeds, yet they are rarely made explicit in prior work. Different starting artifacts determine which solutions are reachable in MLAgentBench, truncated traces can still improve Atari agents, and larger minibatches do not monotonically improve generalization on BBEH. We conclude that the lack of a simple, universal way to set up learning loops across domains is a major hurdle for productionization and adoption. We provide practical guidance for making these choices.",Allen Nie; Xavier Daull; Zhiyi Kuang; Abhinav Akkiraju; Anish Chaudhuri; Max Piasevoli; Ryan Rong; YuCheng Yuan; Prerit Choudhary; Shannon Xiao; Rasool Fakoor; Adith Swaminathan; Ching-An Cheng,2026-03-25,2026,arXiv,arXiv,,"39 pages, 17 figures",cs.LG,arxiv-api,,,,,,,,,2603.23994,,2026-07-18T08:16:45+00:00
ale-0544,The Illusion of Multi-Agent Advantage,https://arxiv.org/abs/2606.13003,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.13003,https://arxiv.org/abs/2606.13003,text/html; charset=utf-8,[2606.13003] The Illusion of Multi-Agent Advantage,"Prevailing wisdom posits that Multi-Agent Systems (MAS) are superior to Single-Agent Systems (SAS), citing advantages like context protection, parallel processing and distributed decision-making. However, empirical support for this claim relies primarily on comparisons with SAS baselines using benchmarks that prioritize isolated reasoning tasks, which do not adequately assess these advantages. Focusing on automatically generated MAS that are designed for enhanced generalizability over manually-designed counterparts, we perform a rigorous, systematic evaluation against SAS, specifically Chain-of-Thought with Self-Consistency (CoT-SC). Across traditional reasoning datasets and tasks with interactive multi-step workflows (e.g., BrowseComp-Plus), we demonstrate that automatic MAS consistently underperform CoT-SC despite being up to 10x more expensive. To isolate these failures from limitations inherent to task structure, we introduce a diagnostic synthetic dataset tailored for MAS featuring explicit task decomposition, context separation and parallelization potential. We show that expert-architected MAS consistently outperforms automatically generated architectures in both raw performance and cost-efficiency on this dataset, demonstrating that existing evaluation frameworks mask critical architectural gaps and inefficiencies of complex MAS by failing to account for the marginal utility of increased computational cost. Critically, systematic deconstruction of the generated MAS architectures reveals that current automated design paradigms produce architectural bloat that prioritizes superficial complexity which does not translate into functional utility, exposing a fundamental misalignment with multi-agent principles.",Prathyusha Jwalapuram; Hehai Lin; Chuyuan Li; Fangkai Jiao; Sudong Wang; Yifei Ming; Zixuan Ke; Chengwei Qin; Giuseppe Carenini; Shafiq Joty,2026-06-11,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2606.13003,,2026-07-18T08:16:45+00:00
ale-0545,The Coming Loop,https://lucumr.pocoo.org/2026/6/23/the-coming-loop/,external,lucumr.pocoo.org,ok,200,https://lucumr.pocoo.org/2026/6/23/the-coming-loop/,https://lucumr.pocoo.org/2026/6/23/the-coming-loop/,text/html; charset=utf-8,The Coming Loop | Armin Ronacher's Thoughts and Writings,"Loops, harnesses, and why even loop skeptics may end up with them.",,2026-06-23,2026,,Armin Ronacher's Thoughts and Writings,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0546,"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,ok,200,https://www.theregister.com/ai-and-ml/2026/06/24/loop-engineering-latest-ai-buzzword-still-needs-humans-in-the-loop/5261735,https://www.theregister.com/ai-and-ml/2026/06/24/loop-engineering-latest-ai-buzzword-still-needs-humans-in-the-loop/5261735,text/html; charset=UTF-8,"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-18T08:16:45+00:00
ale-0547,When Agents Do Not Stop: Uncovering Infinite Agentic Loops in LLM Agents,https://arxiv.org/abs/2607.01641,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.01641,https://arxiv.org/abs/2607.01641,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0548,The Blind Curator: How a Biased Judge Silently Disables Skill Retirement in Self-Evolving Agents,https://arxiv.org/abs/2607.07436,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.07436,https://arxiv.org/abs/2607.07436,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0549,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,ok,200,https://arxiv.org/abs/2607.07504,https://arxiv.org/abs/2607.07504,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0550,The Verification Horizon: No Silver Bullet for Coding Agent Rewards,https://arxiv.org/abs/2606.26300,external,arxiv.org,ok,200,https://arxiv.org/abs/2606.26300,https://arxiv.org/abs/2606.26300,text/html; charset=utf-8,[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-18T08:16:45+00:00
ale-0551,Write Code Like a Human Will Maintain It,https://unstack.io/write-code-like-a-human-will-maintain-it,external,unstack.io,ok,200,https://unstack.io/write-code-like-a-human-will-maintain-it,https://unstack.io/write-code-like-a-human-will-maintain-it,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0552,Claude Code Sends 33k Tokens Before Reading the Prompt,https://systima.ai/blog/claude-code-vs-opencode-token-overhead,external,systima.ai,ok,200,https://systima.ai/blog/claude-code-vs-opencode-token-overhead,https://systima.ai/blog/claude-code-vs-opencode-token-overhead,text/html; charset=utf-8,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-18T08:16:45+00:00
ale-0553,Rethinking the Evaluation of Harness Evolution for Agents,https://arxiv.org/abs/2607.12227,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.12227,https://arxiv.org/abs/2607.12227,text/html; charset=utf-8,[2607.12227] Rethinking the Evaluation of Harness Evolution for Agents,"We revisit the evaluation of automatic harness evolution for LLM agents. Existing harness evolution methods use unit test cases to search for harness configurations and then report final performance on the same public benchmark. This protocol raises two fundamental concerns. First, harness evolution is itself an iterative search procedure that repeatedly evaluates and revises candidate harnesses using task feedback. As in agentic test-time scaling, it should therefore be compared with simple task-level search baselines under matched feedback and inference budgets to determine whether its gains arise from improved harness design or from additional search alone. Second, because the search and the final evaluation share the same benchmark, the reported gains risk overfitting to that specific task set. To address these concerns, we conduct an extensive evaluation comparing harness evolution with simple test-time scaling and discovery baselines under comparable feedback and inference budgets, and also evaluate evolved harnesses on held-out tasks to assess whether the discovered improvements generalize. Experiments on Terminal-Bench 2.1 with GPT-5.4 and Claude Opus 4.6 show that automatic harness evolution does not consistently outperform simple test-time scaling methods and exhibits limited generalization. Our results raise important questions about the effectiveness of automatic harness evolution and highlight the need for fairer evaluation protocols and benchmarks for automatic harness design. Our code is available at https://github.com/rethinking-harness-evolution.",Yike Wang; Huaisheng Zhu; Zhengyu Hu; Yige Yuan; Zhengyu Chen; Shakti Senthil; Hannaneh Hajishirzi; Yulia Tsvetkov; Pradeep Dasigi; Teng Xiao,2026-07-14,2026,arXiv,arXiv,,,cs.AI,arxiv-api,,,,,,,,,2607.12227,,2026-07-18T08:16:45+00:00
ale-0554,Compaction as Epistemic Failure: How Agentic LLM Tools Fabricate Confirmed Results from Killed Processes,https://arxiv.org/abs/2607.13071,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.13071,https://arxiv.org/abs/2607.13071,text/html; charset=utf-8,[2607.13071] Compaction as Epistemic Failure: How Agentic LLM Tools Fabricate Confirmed Results from Killed Processes,"Agentic LLM coding tools compress long session histories into compaction summaries that subsequent sessions inherit as ground truth. This paper documents a failure mode in Claude Code where partial standard output from timed-out commands (exit code 143) is recorded in compaction summaries as confirmed results, propagating false positives across sessions and model versions without re-verification. The underlying mechanism is a conflation of observation and persistence, where information that appeared in the terminal is treated as equivalent to information written to durable storage. This finding extends the analysis of LLM self-evaluation failures reported in prior work on non-determinism in LLM-as-judge grading by showing that agentic tools exhibit analogous reliability deficits when reporting on their own operational outcomes. The failure has direct implications for any workflow that relies on agentic session continuity for data processing, scientific computation, or multi-step automation.",Hiroki Tamba,2026-07-11,2026,arXiv,arXiv,,"8 pages, companion to arXiv:2606.26185",cs.SE,arxiv-api,,,,,,,,,2607.13071,,2026-07-18T08:16:45+00:00
ale-0555,Do Agent Optimizers Compound? A Continual-Learning Evaluation on Terminal-Bench 2.0,https://arxiv.org/abs/2607.14004,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14004,https://arxiv.org/abs/2607.14004,text/html; charset=utf-8,[2607.14004] Do Agent Optimizers Compound? A Continual-Learning Evaluation on Terminal-Bench 2.0,"Most reported gains from agent-optimization methods are one-shot: an agent is optimized against a fixed benchmark and the resulting improvement is reported as if it were a stable property of the method. This does not test the setting that matters for deployed agents, where optimization is applied recursively as new failures and new tasks appear over time. The central question this raises is whether optimizer-driven gains compound: after an agent has been optimized once, can it be optimized again on newly arrived tasks without eroding the gains the first round produced? We study this question with a two-phase continual-learning evaluation built from hard tasks in Terminal-Bench 2.0, comparing three approaches to agent-harness optimization (GEPA, Meta Harness, and RELAI's Verifiable Continual Learning, RELAI-VCL) under identical optimization budgets. All three methods improve over the baseline agent in the conventional, static, single-phase setting. However, once new tasks are introduced, the methods diverge sharply: GEPA's optimized agent transfers below the unoptimized baseline, Meta Harness transfers well but fails to improve further once given a second optimization budget, and RELAI-VCL is the only method that both transfers positively to unseen tasks and continues improving after those tasks are folded into the optimization objective, reaching the highest pass rate at every evaluated stage and the highest lifelong average pass rate overall (76.4% vs. 66.0% for GEPA, 64.6% for Meta Harness, and 58.7% for the baseline). Our key observation was that optimization gains compounded only when regression control was built into the optimization loop, providing an inductive bias against shortcut solutions that fail to generalize.",Wenxiao Wang; Priyatham Kattakinda; Soheil Feizi,2026-07-15,2026,arXiv,arXiv,,Technical Report by RELAI (relai.ai),cs.AI,arxiv-api,,,,,,,,,2607.14004,,2026-07-18T08:16:45+00:00
ale-0556,Does Multi-Agent Debate Improve AI Feedback on Research Papers?,https://arxiv.org/abs/2607.14713,external,arxiv.org,ok,200,https://arxiv.org/abs/2607.14713,https://arxiv.org/abs/2607.14713,text/html; charset=utf-8,[2607.14713] Does Multi-Agent Debate Improve AI Feedback on Research Papers?,"Probably not, at least for meta-analyses in economics. In a pre-registered, identity-masked, within-paper experiment, the authors of 44 meta-analyses ranked three AI reports on their own paper by usefulness for improving it: a single pass by a frontier model against two multi-agent debate tools we built and expected to win. All reports were held to a common length and template. The authors preferred the single pass, by 0.66 rank points over mad-research (95% CI 0.32 to 1.00) and 0.57 over paper-workshop (0.16 to 0.95), though paper-workshop spent roughly thirty times the tokens. Authors who recalled their journal referee report usually placed it first and never last; in a separate exercise, three AI judges almost always placed the real journal referee report last. Among the three AI reports, Gemini (the judge whose model family wrote none of the reports) would have ranked paper-workshop first in the authors' place, reversing the single-pass preference. The reversal warns against substituting an AI judge for the author. We measure perceived usefulness for finished papers; whether AI should referee papers is a separate question.",Tomas Havranek; Zuzana Irsova,2026-07-16,2026,arXiv,arXiv,,"29 pages, 1 figure, 6 tables. Pre-registered on OSF; data, code, judge prompts, and blinded reports in the replication package on Zenodo. Project page: https://meta-analysis.cz/debate",econ.GN,arxiv-api,,,,,,,,,2607.14713,,2026-07-18T08:16:45+00:00
ale-0557,Awesome Harness Engineering by ai-boost,https://github.com/ai-boost/awesome-harness-engineering,external,github.com,ok,200,https://github.com/ai-boost/awesome-harness-engineering,https://github.com/ai-boost/awesome-harness-engineering,text/html; charset=utf-8,"GitHub - ai-boost/awesome-harness-engineering: Awesome list for AI agent harness engineering: tools, patterns, evals, memory, MCP, permissions, observability, and orchestration. · GitHub","Awesome list for AI agent harness engineering: tools, patterns, evals, memory, MCP, permissions, observability, and orchestration. - ai-boost/awesome-harness-engineering",,2026-03-29,2026,ai-boost/awesome-harness-engineering,GitHub,,,,github-api,ai-boost/awesome-harness-engineering,3119,335,106,"Awesome list for AI agent harness engineering: tools, patterns, evals, memory, MCP, permissions, observability, and orchestration.",NOASSERTION,2026-03-29T15:39:49Z,2026-07-18T07:58:19Z,,,2026-07-18T08:16:45+00:00
ale-0558,Awesome Harness Engineering by walkinglabs,https://github.com/walkinglabs/awesome-harness-engineering,external,github.com,ok,200,https://github.com/walkinglabs/awesome-harness-engineering,https://github.com/walkinglabs/awesome-harness-engineering,text/html; charset=utf-8,GitHub - walkinglabs/awesome-harness-engineering: 🛠️ Awesome tools & guides for harness engineering. · GitHub,🛠️ Awesome tools & guides for harness engineering. - walkinglabs/awesome-harness-engineering,,2026-03-29,2026,walkinglabs/awesome-harness-engineering,GitHub,,,,github-api,walkinglabs/awesome-harness-engineering,3638,295,30,🛠️ Awesome tools & guides for harness engineering.,NOASSERTION,2026-03-29T11:29:37Z,2026-07-18T06:13:25Z,,,2026-07-18T08:16:45+00:00
ale-0559,Awesome Agent Harness,https://github.com/AutoJunjie/awesome-agent-harness,external,github.com,ok,200,https://github.com/AutoJunjie/awesome-agent-harness,https://github.com/AutoJunjie/awesome-agent-harness,text/html; charset=utf-8,GitHub - AutoJunjie/awesome-agent-harness · GitHub,Contribute to AutoJunjie/awesome-agent-harness development by creating an account on GitHub.,,2026-03-05,2026,AutoJunjie/awesome-agent-harness,GitHub,,,,github-api,AutoJunjie/awesome-agent-harness,488,46,19,,,2026-03-05T13:19:10Z,2026-07-17T16:21:08Z,,,2026-07-18T08:16:45+00:00
ale-0560,Awesome Context Engineering,https://github.com/Meirtz/Awesome-Context-Engineering,external,github.com,ok,200,https://github.com/Meirtz/Awesome-Context-Engineering,https://github.com/Meirtz/Awesome-Context-Engineering,text/html; charset=utf-8,"GitHub - Meirtz/Awesome-Context-Engineering: 🔥 Comprehensive survey on Context Engineering: from prompt engineering to production-grade AI systems. hundreds of papers, frameworks, and implementation guides for LLMs and AI agents. · GitHub","🔥 Comprehensive survey on Context Engineering: from prompt engineering to production-grade AI systems. hundreds of papers, frameworks, and implementation guides for LLMs and AI agents. - Meirtz/Awesome-Context-Engineering",,2025-07-02,2025,Meirtz/Awesome-Context-Engineering,GitHub,,,,github-api,Meirtz/Awesome-Context-Engineering,3239,258,45,"🔥 Comprehensive survey on Context Engineering: from prompt engineering to production-grade AI systems. hundreds of papers, frameworks, and implementation guides for LLMs and AI agents.",MIT,2025-07-02T17:46:03Z,2026-07-17T15:17:15Z,,,2026-07-18T08:16:45+00:00
ale-0561,Awesome Prompt Engineering,https://github.com/promptslab/Awesome-Prompt-Engineering,external,github.com,ok,200,https://github.com/promptslab/Awesome-Prompt-Engineering,https://github.com/promptslab/Awesome-Prompt-Engineering,text/html; charset=utf-8,"GitHub - promptslab/Awesome-Prompt-Engineering: This repository contains a hand-curated resources for Prompt Engineering with a focus on Generative Pre-trained Transformer (GPT), ChatGPT, PaLM etc · GitHub","This repository contains a hand-curated resources for Prompt Engineering with a focus on Generative Pre-trained Transformer (GPT), ChatGPT, PaLM etc - GitHub - promptslab/Awesome-Prompt-Engineering: This repository contains a hand-curated resources for Prompt Engineering with a focus on Generative Pre-trained Transformer (GPT), ChatGPT, PaLM etc",,2023-02-09,2023,promptslab/Awesome-Prompt-Engineering,GitHub,,,,github-api,promptslab/Awesome-Prompt-Engineering,6173,726,90,"This repository contains a hand-curated resources for Prompt Engineering with a focus on Generative Pre-trained Transformer (GPT), ChatGPT, PaLM etc",Apache-2.0,2023-02-09T18:22:52Z,2026-07-18T08:03:10Z,,,2026-07-18T08:16:45+00:00
ale-0562,Awesome LLM Agents,https://github.com/kaushikb11/awesome-llm-agents,external,github.com,ok,200,https://github.com/kaushikb11/awesome-llm-agents,https://github.com/kaushikb11/awesome-llm-agents,text/html; charset=utf-8,GitHub - kaushikb11/awesome-llm-agents: A curated list of awesome LLM agents frameworks. · GitHub,A curated list of awesome LLM agents frameworks. Contribute to kaushikb11/awesome-llm-agents development by creating an account on GitHub.,,2023-04-04,2023,kaushikb11/awesome-llm-agents,GitHub,,,,github-api,kaushikb11/awesome-llm-agents,1533,329,162,A curated list of awesome LLM agents frameworks.,,2023-04-04T10:22:43Z,2026-07-15T09:52:09Z,,,2026-07-18T08:16:45+00:00
ale-0563,Awesome AI Agents,https://github.com/e2b-dev/awesome-ai-agents,external,github.com,ok,200,https://github.com/e2b-dev/awesome-ai-agents,https://github.com/e2b-dev/awesome-ai-agents,text/html; charset=utf-8,GitHub - e2b-dev/awesome-ai-agents: A list of AI autonomous agents · GitHub,A list of AI autonomous agents. Contribute to e2b-dev/awesome-ai-agents development by creating an account on GitHub.,,2023-06-19,2023,e2b-dev/awesome-ai-agents,GitHub,,,,github-api,e2b-dev/awesome-ai-agents,28863,3185,855,A list of AI autonomous agents,NOASSERTION,2023-06-19T00:20:06Z,2026-07-18T06:49:47Z,,,2026-07-18T08:16:45+00:00
ale-0564,Awesome CLI Coding Agents,https://github.com/bradAGI/awesome-cli-coding-agents,external,github.com,ok,200,https://github.com/bradAGI/awesome-cli-coding-agents,https://github.com/bradAGI/awesome-cli-coding-agents,text/html; charset=utf-8,"GitHub - bradAGI/awesome-cli-coding-agents: Curated directory of terminal-native AI coding agents and the harnesses that orchestrate them. Covers open-source tools (Pi, OpenCode, Aider, Goose), platform agents (Claude Code, Codex, Gemini CLI), parallel runners, autonomous loops, and agent infrastructure. · GitHub","Curated directory of terminal-native AI coding agents and the harnesses that orchestrate them. Covers open-source tools (Pi, OpenCode, Aider, Goose), platform agents (Claude Code, Codex, Gemini CLI), parallel runners, autonomous loops, and agent infrastructure. - GitHub - bradAGI/awesome-cli-coding-agents: Curated directory of terminal-native AI coding agents and the harnesses that orchestrate them. Covers open-source tools (Pi, OpenCode, Aider, Goose), platform agents (Claude Code, Codex, Gemini CLI), parallel runners, autonomous loops, and agent infrastructure.",,2026-02-07,2026,bradAGI/awesome-cli-coding-agents,GitHub,,,,github-api,bradAGI/awesome-cli-coding-agents,821,220,26,"Curated directory of terminal-native AI coding agents and the harnesses that orchestrate them. Covers open-source tools (Pi, OpenCode, Aider, Goose), platform agents (Claude Code, Codex, Gemini CLI), parallel runners, autonomous loops, and agent infrastructure.",,2026-02-07T00:53:24Z,2026-07-17T22:44:51Z,,,2026-07-18T08:16:45+00:00
ale-0565,Awesome Self-Evolving Agents,https://github.com/XMUDeepLIT/Awesome-Self-Evolving-Agents,external,github.com,ok,200,https://github.com/XMUDeepLIT/Awesome-Self-Evolving-Agents,https://github.com/XMUDeepLIT/Awesome-Self-Evolving-Agents,text/html; charset=utf-8,"GitHub - XMUDeepLIT/Awesome-Self-Evolving-Agents: A Survey of Self-Evolving Agents | A curated list of resources (surveys, papers, benchmarks, and opensource projects) on Self-Evolving Agents. · GitHub","A Survey of Self-Evolving Agents | A curated list of resources (surveys, papers, benchmarks, and opensource projects) on Self-Evolving Agents. - XMUDeepLIT/Awesome-Self-Evolving-Agents",,2026-02-09,2026,XMUDeepLIT/Awesome-Self-Evolving-Agents,GitHub,,,,github-api,XMUDeepLIT/Awesome-Self-Evolving-Agents,332,20,5,"A Survey of Self-Evolving Agents | A curated list of resources (surveys, papers, benchmarks, and opensource projects) on Self-Evolving Agents.",,2026-02-09T10:57:30Z,2026-07-18T03:24:03Z,,,2026-07-18T08:16:45+00:00
ale-0566,Awesome AI Agent Papers,https://github.com/VoltAgent/awesome-ai-agent-papers,external,github.com,ok,200,https://github.com/VoltAgent/awesome-ai-agent-papers,https://github.com/VoltAgent/awesome-ai-agent-papers,text/html; charset=utf-8,"GitHub - VoltAgent/awesome-ai-agent-papers: A curated collection of AI agent research papers released in 2026, covering agent engineering, memory, evaluation, workflows, and autonomous systems. · GitHub","A curated collection of AI agent research papers released in 2026, covering agent engineering, memory, evaluation, workflows, and autonomous systems. - VoltAgent/awesome-ai-agent-papers",,2026-02-10,2026,VoltAgent/awesome-ai-agent-papers,GitHub,,,,github-api,VoltAgent/awesome-ai-agent-papers,1592,165,0,"A curated collection of AI agent research papers released in 2026, covering agent engineering, memory, evaluation, workflows, and autonomous systems.",MIT,2026-02-10T10:58:31Z,2026-07-17T18:52:18Z,,,2026-07-18T08:16:45+00:00
ale-0567,awesome-ralph,https://github.com/snwfdhmp/awesome-ralph,external,github.com,ok,200,https://github.com/snwfdhmp/awesome-ralph,https://github.com/snwfdhmp/awesome-ralph,text/html; charset=utf-8,"GitHub - snwfdhmp/awesome-ralph: A curated list of resources about Ralph, the AI coding technique that runs AI coding agents in automated loops until specifications are fulfilled. · GitHub","A curated list of resources about Ralph, the AI coding technique that runs AI coding agents in automated loops until specifications are fulfilled. - snwfdhmp/awesome-ralph",,2026-01-19,2026,snwfdhmp/awesome-ralph,GitHub,,,,github-api,snwfdhmp/awesome-ralph,913,72,12,"A curated list of resources about Ralph, the AI coding technique that runs AI coding agents in automated loops until specifications are fulfilled.",,2026-01-19T08:42:54Z,2026-07-13T12:09:52Z,,,2026-07-18T08:16:45+00:00
ale-0568,Awesome Agent Loops,https://github.com/serenakeyitan/awesome-agent-loops,external,github.com,ok,200,https://github.com/serenakeyitan/awesome-agent-loops,https://github.com/serenakeyitan/awesome-agent-loops,text/html; charset=utf-8,"GitHub - serenakeyitan/awesome-agent-loops: A curated collection of the best /loop, /goal, and /schedule uses for Claude Code & Codex — real commands sourced from Twitter/X. The awesome-list of agent loops. · GitHub","A curated collection of the best /loop, /goal, and /schedule uses for Claude Code & Codex — real commands sourced from Twitter/X. The awesome-list of agent loops. - serenakeyitan/awesome-agent-loops",,2026-06-09,2026,serenakeyitan/awesome-agent-loops,GitHub,,,,github-api,serenakeyitan/awesome-agent-loops,194,16,2,"A curated collection of the best /loop, /goal, and /schedule uses for Claude Code & Codex — real commands sourced from Twitter/X. The awesome-list of agent loops.",CC-BY-4.0,2026-06-09T01:26:51Z,2026-07-15T11:44:20Z,,,2026-07-18T08:16:45+00:00
ale-0569,Awesome Loop Models,https://github.com/huskydoge/Awesome-Loop-Models,external,github.com,ok,200,https://github.com/huskydoge/Awesome-Loop-Models,https://github.com/huskydoge/Awesome-Loop-Models,text/html; charset=utf-8,GitHub - huskydoge/Awesome-Loop-Models: A curated list of papers and selected technical blogs on Loop Models. · GitHub,A curated list of papers and selected technical blogs on Loop Models. - huskydoge/Awesome-Loop-Models,,2026-04-24,2026,huskydoge/Awesome-Loop-Models,GitHub,,,,github-api,huskydoge/Awesome-Loop-Models,215,8,3,A curated list of papers and selected technical blogs on Loop Models.,MIT,2026-04-24T12:16:55Z,2026-07-18T06:50:42Z,,,2026-07-18T08:16:45+00:00
ale-0570,Resource Atlas,https://chaoyue0307.github.io/awesome-loop-engineering/,external,chaoyue0307.github.io,ok,200,https://chaoyue0307.github.io/awesome-loop-engineering/,https://chaoyue0307.github.io/awesome-loop-engineering/,text/html; charset=utf-8,Awesome Loop Engineering,"Explore 579 resources from model recurrence to governed agent operations, then build with 20 patterns, 20 contracts, and 8 runtime starters.",Chaoyue He,,,,chaoyue0307.github.io,,,,html-meta,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0571,Hugging Face dataset,https://huggingface.co/datasets/cy0307/awesome-loop-engineering,external,huggingface.co,ok,200,https://huggingface.co/datasets/cy0307/awesome-loop-engineering,https://huggingface.co/datasets/cy0307/awesome-loop-engineering,text/html; charset=utf-8,cy0307/awesome-loop-engineering · Datasets at Hugging Face,We’re on a journey to advance and democratize artificial intelligence through open source and open science.,,,,,Hugging Face,,,,domain-fallback,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0572,Dataset export guide,data/README.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/data/README.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/data/README.md,,Dataset export guide,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0573,Runtime selection guide,meta/RUNTIME_SELECTION.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/meta/RUNTIME_SELECTION.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/meta/RUNTIME_SELECTION.md,,Runtime selection guide,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0574,Future Directions agenda,FUTURE-DIRECTIONS.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/FUTURE-DIRECTIONS.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/FUTURE-DIRECTIONS.md,,Future Directions agenda,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0575,Release notes,https://github.com/ChaoYue0307/awesome-loop-engineering/releases,external,github.com,ok,200,https://github.com/ChaoYue0307/awesome-loop-engineering/releases,https://github.com/ChaoYue0307/awesome-loop-engineering/releases,text/html; charset=utf-8,Releases · ChaoYue0307/awesome-loop-engineering · GitHub,"🔁 Explore 579 resources from model recurrence to governed agent operations · Build with 20 patterns, 20 contracts, and 8 runtime starters · Atlas + dataset. - Releases · ChaoYue0307/awesome-loop-engineering",,2026-06-09,2026,GitHub Releases,GitHub,,,,github-api,ChaoYue0307/awesome-loop-engineering,31,6,9,"🔁 Explore 579 resources from model recurrence to governed agent operations · Build with 20 patterns, 20 contracts, and 8 runtime starters · Atlas + dataset.",CC0-1.0,2026-06-09T16:17:27Z,2026-07-18T07:38:30Z,,,2026-07-18T08:16:45+00:00
ale-0576,Roadmap,ROADMAP.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/ROADMAP.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/ROADMAP.md,,Roadmap,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0577,Launch article,posts/launch.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/posts/launch.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/posts/launch.md,,Launch article,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0578,Discussion guide,meta/DISCUSSIONS.md,local_path,,local_ok,,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/meta/DISCUSSIONS.md,https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/meta/DISCUSSIONS.md,,Discussion guide,,,,2026,GitHub,GitHub,,,,repository,,,,,,,,,,,2026-07-18T08:16:45+00:00
ale-0579,Show your Loop Engineering patterns,https://github.com/ChaoYue0307/awesome-loop-engineering/discussions/2,external,github.com,ok,200,https://github.com/ChaoYue0307/awesome-loop-engineering/discussions/2,https://github.com/ChaoYue0307/awesome-loop-engineering/discussions/2,text/html; charset=utf-8,Show your Loop Engineering patterns · ChaoYue0307/awesome-loop-engineering · Discussion #2 · GitHub,Show your Loop Engineering patterns,,2026-06-09,2026,GitHub Discussions,GitHub,,,,github-api,ChaoYue0307/awesome-loop-engineering,31,6,9,"🔁 Explore 579 resources from model recurrence to governed agent operations · Build with 20 patterns, 20 contracts, and 8 runtime starters · Atlas + dataset.",CC0-1.0,2026-06-09T16:17:27Z,2026-07-18T07:38:30Z,,,2026-07-18T08:16:45+00:00