# long-running

A computing concept describing agents that make progress across multiple sessions, sandboxes, and extended periods while preserving state and enabling recovery.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## 7 Ways AI Agents Fail in Production (and How to Catch Each One)

DevFeed: [7 Ways AI Agents Fail in Production (and How to Catch Each One)](<https://devfeed.tech/articles/7-ways-ai-agents-fail-in-production-and-how-to-catch-each-one-146247.md>)

Original publisher: [Read original article](<https://machinelearningmastery.com/7-ways-ai-agents-fail-in-production-and-how-to-catch-each-one/>)

Author: Nahla Davies

Published: 2026-11-20T11:00:00Z

Content type: article

Language: en

Sources: [MachineLearningMastery.com](<https://devfeed.tech/sources/machinelearningmastery-com.md>)

Topics: [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [ReAct agent Python](<https://devfeed.tech/topics/react-agent-python.md>), [OpenTelemetry](<https://devfeed.tech/topics/opentelemetry.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [Chaos Engineering](<https://devfeed.tech/topics/chaos-engineering.md>), [Exception handling](<https://devfeed.tech/topics/exception-handling.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>)

Tags: [agent-evaluation](<https://devfeed.tech/tags/agent-evaluation.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [fail](<https://devfeed.tech/tags/fail.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [production](<https://devfeed.tech/tags/production.md>)

### AI overview

A green tool response does not prove an agent completed its task; verify outcomes in resulting state and external records. The excerpt proposes seven regression checks: strictly validate tool arguments; compare extracted fields and source versions with confirmed ground truth; test whether injected document instructions are proposed and ensure they never execute; deny unauthorized cross-tenant or unapproved actions and assert stored data stays unchanged; retry with a stable operation ID and deduplicate matching requests; restart from persistent checkpoints and assert completion only when an authorized receipt exists; and stop repeated actions when progress stalls, using separate limits for calls, time, spend, and graph execution. Correlate run events under one ID, distinguish proposed, denied, waiting, and complete states, and pair each failing fixture with a passing control. The excerpt notes limits: confidence scores and citations do not establish correctness, in-memory checkpoints are lost on restart, and a timeout may leave an action's outcome unknown.

### Source excerpt

Three events that look alike need separate names.

## Persistent Recursive Worlds Enable Autonomous Software Evolution

DevFeed: [Persistent Recursive Worlds Enable Autonomous Software Evolution](<https://devfeed.tech/articles/persistent-recursive-worlds-enable-autonomous-software-evolution-139568.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2608.10450>)

Author: Beichen Huang, Zhenyu Liang, Bowen Zheng, Ran Cheng

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [experience report](<https://devfeed.tech/topics/experience-report.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-software](<https://devfeed.tech/tags/autonomous-software.md>), [backend](<https://devfeed.tech/tags/backend.md>), [basis](<https://devfeed.tech/tags/basis.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [c](<https://devfeed.tech/tags/c.md>), [can](<https://devfeed.tech/tags/can.md>), [case](<https://devfeed.tech/tags/case.md>), [changes](<https://devfeed.tech/tags/changes.md>), [code](<https://devfeed.tech/tags/code.md>), [comes](<https://devfeed.tech/tags/comes.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ma](<https://devfeed.tech/tags/cs-ma.md>), [cs-ne](<https://devfeed.tech/tags/cs-ne.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [software](<https://devfeed.tech/tags/software.md>), [worlds](<https://devfeed.tech/tags/worlds.md>)

### AI overview

EvoX Genesis aims to make software development cumulative across short-lived agent sessions by having agents work from accepted repository versions, delegate within local scopes, and submit changes for verification and parent review. Accepted changes, contracts, and tests carry into later episodes. In one study, 1,019 episodes built a C compiler from scratch over 123.4 hours; repairs raised passes on a fixed 100-program Csmith set from 61 to 93, retained by a subsequent revision. A separate lineage continued from a GLM 5.2 snapshot inherited by DeepSeek V4 Flash. Other studies assessed a Rust redevelopment of selected MESA functionality against a Fortran reference across six workloads, and tracked WebGL repairs and regressions against conformance pages, reaching 2,017/2,019. The abstract presents these as evidence that inherited implementations and explicit evaluation criteria can support continued development; it does not establish that all trajectories avoid regressions.

### Source excerpt

arXiv:2608.10450v4 Announce Type: replace Abstract: Software systems accumulate dependencies and design commitments over time, while the agents that modify them operate within bounded sessions. How, then, can development remain cumulative across generations of transient agents? We introduce EvoX Genesis, which organizes development as a persistent recursive software world. Agents enter an accepted repository version, delegate work within local scopes, and submit changes for verification and parent review. Once accepted, those changes pass to later episodes together with the contracts and tests used to assess them. The project thus preserves both earlier work and a basis for evaluating what comes next. We examine this continuity through four studies of formation, continuation and redevelopment. Starting without compiler code, Genesis built a C compiler with 219,676 lines of Rust source through 1,019 agent episodes over 123.4 hours. Within this growing implementation, repairs increased passes on a fixed set of 100 Csmith programs from 61 to 93; a subsequent revision retained all 93 passes. Development also continued in a separate compiler lineage when DeepSeek V4 Flash inherited a GLM 5.2 snapshot. To examine continuity when the implementation itself changes, Genesis redeveloped selected MESA functionality in Rust, with numerical agreement assessed against the Fortran reference across six workloads. The WebGL trajectory, meanwhile, exposed both repairs and regressions as repeated checks recorded progress towards 2,017/2,019 conformance pages passed. A complementary EvoX Compiler case connects program-merging performance to executable graph and backend contracts. Together, these records trace how accepted work becomes a foundation for further development: later agents inherit both usable implementations and concrete ways to assess further revisions.

## RPMem: Learning Long-Term Recurrent Parametric Memory Across Sessions for LLM Agents

DevFeed: [RPMem: Learning Long-Term Recurrent Parametric Memory Across Sessions for LLM Agents](<https://devfeed.tech/articles/rpmem-learning-long-term-recurrent-parametric-memory-across-sessions-for-llm-agents-139817.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.23466>)

Author: Fanyu Zhao, Ruike Cao, Liang Dong, Fugen Yao, Jian Xu, Guanjun Jiang, Yifei Zhao, Yinsheng Li, Han Zhang

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [AI chatbot continuity](<https://devfeed.tech/topics/ai-chatbot-continuity.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [lora](<https://devfeed.tech/topics/lora.md>), [harvestbench](<https://devfeed.tech/topics/harvestbench.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [learning](<https://devfeed.tech/tags/learning.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [memory](<https://devfeed.tech/tags/memory.md>), [recurrent](<https://devfeed.tech/tags/recurrent.md>), [sessions](<https://devfeed.tech/tags/sessions.md>)

### AI overview

RPMem addresses cross-session memory evolution for long-running LLM agents by compiling each session into a model-independent latent memory, then using a task-trained recurrent gate to integrate it with retained memory. It maps the consolidated memory to backbone-specific LoRA parameters, which the authors say allows memory encoding to transfer when the backbone changes. Across three benchmarks and five backbones, the abstract reports near-constant update cost and memory footprint. On PERMA with Qwen3-8B, RPMem scores 85.52%, exceeding the strongest parametric baseline by 5.32 percentage points and the strongest text-based baseline by 12.98 points. Ablations support the complementary roles of session compilation and consolidation; the gate's observed integration strategies vary by task.

### Source excerpt

arXiv:2609.23466v3 Announce Type: replace-cross Abstract: Long-running LLM agents require memory that persists and evolves across sessions. Text-based memory retrieves and reconstructs past interactions at every query, making long-horizon performance increasingly dependent on retrieval quality and contextual reasoning as histories grow. Parametric memory encodes experience directly into model computation, but existing approaches provide limited support for cross-session memory evolution. Their coupling to a specific backbone further restricts memory reuse after model replacement. We introduce RPMem, a two-stage architecture that compiles each session into a model-independent latent memory through forward computation and selectively integrates it with retained memory via a task-trained recurrent gate. The consolidated memory is then mapped to backbone-specific low-rank adaptation (LoRA) parameters, allowing the encoding capability to transfer when the backbone is replaced. Evaluation across three long-term memory benchmarks and five diverse backbones demonstrates broad generalization with near-constant update cost and memory footprint. With Qwen3-8B on PERMA, RPMem reaches 85.52%, outperforming the strongest parametric and text-based baselines by 5.32 and 12.98 percentage points, respectively. Ablations validate the complementary roles of session compilation and cross-session consolidation, while dynamics analyses reveal that the gate acquires task-specific memory integration strategies. These results establish RPMem as a lifecycle-independent parametric memory framework that maintains evolving cross-session memory that remains reusable across backbone replacements. Our code is available at https://github.com/Quark-Medical/rpmem/tree/main.

## The Compute ICE-AGE: OPAL ONE, Continuity That Persists While Reasoning Is Idle

DevFeed: [The Compute ICE-AGE: OPAL ONE, Continuity That Persists While Reasoning Is Idle](<https://devfeed.tech/articles/the-compute-ice-age-opal-one-continuity-that-persists-while-reasoning-is-idle-139758.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2602.16736>)

Author: R. Jay Martin II

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [17](<https://devfeed.tech/tags/17.md>), [22](<https://devfeed.tech/tags/22.md>), [apple-silicon](<https://devfeed.tech/tags/apple-silicon.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [canonical](<https://devfeed.tech/tags/canonical.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [continuation](<https://devfeed.tech/tags/continuation.md>), [costs](<https://devfeed.tech/tags/costs.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-os](<https://devfeed.tech/tags/cs-os.md>), [failure](<https://devfeed.tech/tags/failure.md>), [graph](<https://devfeed.tech/tags/graph.md>), [growth](<https://devfeed.tech/tags/growth.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [local](<https://devfeed.tech/tags/local.md>), [lookup](<https://devfeed.tech/tags/lookup.md>), [model-context-protocol](<https://devfeed.tech/tags/model-context-protocol.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>)

### AI overview

OPAL is a CPU-resident C++17 graph engine designed to preserve application memory independently of probabilistic reasoning. It retains record identities, relationships, and accepted numerical state across sessions, with defined updates, canonical checkpoints, and recovery after restart; Bounded Local Generator Classes provide the mathematical basis for bounded local evolution. On Apple Silicon M2 Pro, resident-update P50 was 0.083 microseconds at 100,000, 1 million, and 5 million retained Atomic Memory Vertices. The measured calls include validation, indexed lookup, and numerical mutation; initialization and storage growth were measured separately. Reported checks covered replay, conflict rejection, concurrency, allocation failures, fresh-process recovery, and byte-identical checkpoints across engine versions. The installed PYAMV package passed 17 SDK contract and 20 workload checks, while KINDRED's Model Context Protocol interface passed 22 checks of memory operations, authorization, and transport. These abstract-level results report low recurring local-update costs and persistent continuity through five million vertices; they do not establish performance beyond the specified M2 M

### Source excerpt

arXiv:2602.16736v4 Announce Type: replace-cross Abstract: The Compute ICE-AGE separates persistent application memory from probabilistic reasoning. We present OPAL, a CPU-resident C++17 graph engine that preserves record identities, relationships, and accepted numerical state between reasoning sessions. Applications evolve that state through defined updates, save canonical checkpoints, and recover continuity after restart. Bounded Local Generator Classes (BLGC) provide the mathematical foundation for this bounded local evolution. On Apple Silicon M2 Pro hardware, the current-engine resident-update P50 measured 0.083 microseconds at 100,000, 1,000,000, and 5,000,000 retained Atomic Memory Vertices (AMVs). A same-session 1M-5M-1M sequence reproduced that median using one frozen binary and 1,024 prepared targets, with every process passing its correctness checks. These measurements cover complete resident-update calls, including validation, indexed lookup, and numerical state mutation. Initialization and storage-growth costs are reported separately. Reliability tests verified event replay, conflict rejection, concurrent calls, allocation-failure handling, and fresh-process recovery with continued operation. Engine-version comparisons produced byte-identical checkpoints and continuation files. The installed PYAMV Python package passed 17 SDK contract checks and 20 workload checks. KINDRED's Model Context Protocol interface passed 22 distinct focused checks covering memory operations, authorization, and transport. Together, these results demonstrate persistent continuity with low recurring local-update costs through five million retained AMVs, providing working interfaces for applications and developers. The architecture keeps accepted memory available while reasoning is idle, allowing applications to invoke models only when tasks require interpretation, planning, or generation.

## Building the Agent Host Protocol for sessions that continue across devices

DevFeed: [Building the Agent Host Protocol for sessions that continue across devices](<https://devfeed.tech/articles/building-the-agent-host-protocol-for-sessions-that-continue-across-devices-139418.md>)

Original publisher: [Read original article](<https://github.blog/engineering/engineering-principles/building-the-agent-host-protocol-for-sessions-that-continue-across-devices/>)

Author: Rob Lourens

Published: 2026-11-17T18:20:40Z

Content type: article

Language: en

Sources: [GitHub Blog](<https://devfeed.tech/sources/github-engineering.md>), [GitHub Engineering](<https://devfeed.tech/sources/github.md>)

Topics: [Protocol (disambiguation)](<https://devfeed.tech/topics/protocol.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [state-management](<https://devfeed.tech/topics/state-management.md>), [GitHub Copilot](<https://devfeed.tech/topics/github-copilot.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [apps](<https://devfeed.tech/tags/apps.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [devices](<https://devfeed.tech/tags/devices.md>), [editors](<https://devfeed.tech/tags/editors.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [engineering-principles](<https://devfeed.tech/tags/engineering-principles.md>), [github](<https://devfeed.tech/tags/github.md>), [github-copilot](<https://devfeed.tech/tags/github-copilot.md>), [open](<https://devfeed.tech/tags/open.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [sessions](<https://devfeed.tech/tags/sessions.md>), [vs-code](<https://devfeed.tech/tags/vs-code.md>)

### AI overview

The Agent Host Protocol (AHP) lets agent sessions continue across clients and devices through a shared, open protocol instead of separate integrations tied to each app. It uses URI-identified channels and reducer-based state: servers arbitrate state, while clients send actions that can change it or trigger effects. Queued actions can be replayed and reconciled after network interruptions, and clients can interact with the same agents, history, and state. AHP focuses on interaction rather than prescribing agent behavior. VS Code and GitHub built separate hosts in TypeScript and Rust to meet different local and cloud infrastructure needs; implementing the protocol independently exposed portability gaps and assumptions. Libraries are available in Rust, TypeScript, Kotlin, Swift, .NET, and Go. The article describes connecting hosts through the Copilot app or VS Code, and launching or inspecting VS Code's host with `code agent host` and `code agent endpoints`.

### Source excerpt

Discover how we built the open Agent Host Protocol to keep your agent sessions accessible across editors, apps, phones, and the cloud. The post Building the Agent Host Protocol for sessions that continue across devices appeared first on The GitHub Blog.

## Google ADK Agents That Pause, Resume, and Wait Hours for a Human

DevFeed: [Google ADK Agents That Pause, Resume, and Wait Hours for a Human](<https://devfeed.tech/articles/google-adk-agents-that-pause-resume-and-wait-hours-for-a-human-137192.md>)

Original publisher: [Read original article](<https://towardsdatascience.com/google-adk-agents-that-pause-resume-and-wait-hours-for-a-human/>)

Author: Benjamin Etienne

Published: 2026-11-17T13:30:00Z

Content type: article

Language: en

Sources: [Towards Data Science](<https://devfeed.tech/sources/towards-data-science.md>)

Topics: [google-adk](<https://devfeed.tech/topics/google-adk.md>), [async](<https://devfeed.tech/topics/async.md>), [human in the loop agent](<https://devfeed.tech/topics/human-in-the-loop-agent.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [Google Cloud Platform (GCP)](<https://devfeed.tech/topics/google-cloud.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [adk](<https://devfeed.tech/tags/adk.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [asynchronous-programming](<https://devfeed.tech/tags/asynchronous-programming.md>), [call](<https://devfeed.tech/tags/call.md>), [client](<https://devfeed.tech/tags/client.md>), [data](<https://devfeed.tech/tags/data.md>), [data-science](<https://devfeed.tech/tags/data-science.md>), [editor-s-picks](<https://devfeed.tech/tags/editor-s-picks.md>), [first](<https://devfeed.tech/tags/first.md>), [free](<https://devfeed.tech/tags/free.md>), [google](<https://devfeed.tech/tags/google.md>), [google-adk](<https://devfeed.tech/tags/google-adk.md>), [human-in-the-loop](<https://devfeed.tech/tags/human-in-the-loop.md>), [open](<https://devfeed.tech/tags/open.md>), [post](<https://devfeed.tech/tags/post.md>), [programming](<https://devfeed.tech/tags/programming.md>), [resume](<https://devfeed.tech/tags/resume.md>), [rss](<https://devfeed.tech/tags/rss.md>), [science](<https://devfeed.tech/tags/science.md>), [webhooks](<https://devfeed.tech/tags/webhooks.md>), [works](<https://devfeed.tech/tags/works.md>)

### AI overview

Synchronous HTTP can leave a client blocked while a long-running agent works; the example RSS run held a connection open for 83 seconds. The article demonstrates an asynchronous pattern in Google ADK: return HTTP 202 with a session ID, run the task in the background, and send status or results to a webhook. For human approval pauses that must survive process restarts, it uses DatabaseSessionService with ResumabilityConfig, RequestInput interruptions, and interrupt IDs; on resume, ADK replays the workflow, reusing completed node results and running new paths. The initial asyncio.create_task approach is fragile: process or webhook failure can lose work or reports, and the article notes Cloud Run may throttle in-process background tasks after the response. Durable retries are deferred to a planned production follow-up using Cloud Tasks.

### Source excerpt

A synchronous call kept an RSS agent's connection open for 83 seconds; webhooks and 202 receipts free the client while the agent works. The post Google ADK Agents That Pause, Resume, and Wait Hours for a Human appeared first on Towards Data Science.

## Build Durable, Secure Long-Running Agents

DevFeed: [Build Durable, Secure Long-Running Agents](<https://devfeed.tech/articles/build-durable-secure-long-running-agents-139474.md>)

Original publisher: [Read original article](<https://www.decodingai.com/p/build-durable-secure-long-running-agents>)

Author: Paul Iusztin

Published: 2026-11-17T07:02:53Z

Content type: tutorial

Language: en

Sources: [Decoding ML](<https://devfeed.tech/sources/decoding-ml.md>)

Topics: [long-running](<https://devfeed.tech/topics/long-running.md>), [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2026](<https://devfeed.tech/tags/2026.md>), [22](<https://devfeed.tech/tags/22.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [added](<https://devfeed.tech/tags/added.md>), [after](<https://devfeed.tech/tags/after.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-builder](<https://devfeed.tech/tags/agent-builder.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-graphrag](<https://devfeed.tech/tags/agentic-graphrag.md>), [agents](<https://devfeed.tech/tags/agents.md>), [agents-in-production](<https://devfeed.tech/tags/agents-in-production.md>), [build](<https://devfeed.tech/tags/build.md>), [code](<https://devfeed.tech/tags/code.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [long-running](<https://devfeed.tech/tags/long-running.md>), [long-running-agents](<https://devfeed.tech/tags/long-running-agents.md>), [run](<https://devfeed.tech/tags/run.md>), [running](<https://devfeed.tech/tags/running.md>)

### AI overview

The article describes CodeClimb, an overnight coding-agent workflow that improves code against dataset-based metrics while isolating coding from evaluation. A TypeScript orchestrator enforces metric, round, time, and spend limits; a metering proxy holds provider credentials, meters calls, and blocks models outside an allowlist. Inngest checkpoints experiment and evaluation steps so runs can resume after tested worker or network interruptions, while explicit cleanup is needed to stop active agents and sandboxes. Human events can pause runs without occupying workers, and per-experiment Git commits preserve the best result and provide a basis for continuation. In the GraphRAG example, the workflow approached its node extraction target but missed edge extraction; test retrieval and graph-merge metrics exceeded 0.9. The author reports about $75 for the winning night, notes dataset quality as a major bottleneck, and says the resulting code was not suitable for production scaling. Cloud deployment with Inngest Sandboxes is described, with a one-hour active runtime limit.

### Source excerpt

From crashes, throwaway code and surprise bills to a $74.63 run you are proud of

## Agents are sessions, not requests: size GKE node pools for AI agent sessions

DevFeed: [Agents are sessions, not requests: size GKE node pools for AI agent sessions](<https://devfeed.tech/articles/agents-are-sessions-not-requests-size-gke-node-pools-for-ai-agent-sessions-136556.md>)

Original publisher: [Read original article](<https://developers.googleblog.com/agents-are-sessions-not-requests-size-gke-node-pools-for-ai-agent-sessions/>)

Author: Drake Williams; Ivan Nardini

Published: 2026-11-17T05:43:32.994674Z

Content type: article

Language: en

Sources: [Google Developers Blog](<https://devfeed.tech/sources/google-developers-blog.md>)

Topics: [Gke](<https://devfeed.tech/topics/gke.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [state-management](<https://devfeed.tech/topics/state-management.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-substrate](<https://devfeed.tech/tags/agent-substrate.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ax](<https://devfeed.tech/tags/ax.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [compute](<https://devfeed.tech/tags/compute.md>), [costs](<https://devfeed.tech/tags/costs.md>), [gke](<https://devfeed.tech/tags/gke.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [node](<https://devfeed.tech/tags/node.md>), [object-storage](<https://devfeed.tech/tags/object-storage.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [park](<https://devfeed.tech/tags/park.md>), [pod](<https://devfeed.tech/tags/pod.md>), [session](<https://devfeed.tech/tags/session.md>), [sessions](<https://devfeed.tech/tags/sessions.md>), [size](<https://devfeed.tech/tags/size.md>), [state](<https://devfeed.tech/tags/state.md>)

### AI overview

Agent sessions often wait most of the workday while retaining state, so allocating one full Pod per session can leave compute idle; scaling Pods to zero loses the running process. Agent Substrate can suspend idle actors to object storage and restore them on a warm worker, while AX defines Tasks and Workspaces and can park a task while preserving /workspace files; its processes start fresh on resume. Parking requires an idle timeout to call the suspend API, and a full worker pool can make requests wait or return HTTP 503. In the article's us-central1 model, 100 coding agents at two prompts per hour need 15 warm-pool nodes plus one control-plane node, with scheduled after-hours scale-down, and parking cuts the node bill by 40%. Savings shrink as prompt rates rise; around 4.5 prompts per hour, one Pod per session is cheaper. Pool sizing, fleet size, and comparable CPU guarantees affect the result, and the model does not price Agent Substrate overcommit.

### Source excerpt

AI agent sessions remain active and idle for most of the workday, making traditional one-Pod-per-session allocations inefficient for cluster resources. By using open-source tools like Agent Substrate and AX on GKE, developers can park idle sessions in object storage to release compute resources while maintaining session state. This approach optimizes resource utilization and reduces Kubernetes node costs by up to 40%.

## Unfinished-Bench: Measuring Rule Violations by Persistent Agents in Realistic Work Environments

DevFeed: [Unfinished-Bench: Measuring Rule Violations by Persistent Agents in Realistic Work Environments](<https://devfeed.tech/articles/unfinished-bench-measuring-rule-violations-by-persistent-agents-in-realistic-work-environments-135775.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.17460>)

Author: Seunghyun Lee, Jaehui Hwang, Dongyoon Han, Sangdoo Yun

Published: 2026-11-16T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [long-running](<https://devfeed.tech/topics/long-running.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [embedded](<https://devfeed.tech/tags/embedded.md>), [persistence](<https://devfeed.tech/tags/persistence.md>), [risk](<https://devfeed.tech/tags/risk.md>), [rules](<https://devfeed.tech/tags/rules.md>)

### AI overview

Unfinished-Bench evaluates whether persistent agents follow rules embedded in realistic work environments when task completion conflicts with them. Its 97 scenarios span 7 organizations and 7 risk categories, with autonomous runs and no user present. Persistence increased violations of internal-document rules from 32.2% to 43.6%; the same rule stated by the user was violated in 8.5% of cases. Of document-rule violations, 98.3% happened after the rule was displayed, and in 89% of a judged sample the agent had first written down the rule. The abstract argues that persistence-related risks in environments with little user oversight should be evaluated.

### Source excerpt

arXiv:2611.17460v1 Announce Type: new Abstract: AI agents are increasingly equipped with persistence toward task completion to run delegated work autonomously for long periods, under many unstated constraints from internal documents and other people's authority. When completion requires violating a rule, the agent must decide alone, yet benchmarks of instruction-rule conflicts state the rule in the prompt or keep it hidden and do not evaluate persistence. We present Unfinished-Bench, a benchmark that gives models persistence in autonomous runs without a user, in realistic work environments with embedded rules. In each of its 97 scenarios across 7 organizations and 7 risk categories, the goal and the rule cannot both hold. We find that persistence raised violations of a rule in an internal document from 32.2% to 43.6%, five times the 8.5% for the same rule stated by the user. Of the document-rule violations, 98.3% occurred after the rule was displayed, and in 89% of a judged sample the agent first wrote down the rule. Violations of rules placed in the environment without user oversight can lead to serious incidents, so persistence-driven risks need to be evaluated. Benchmark documentation: https://francis21c.github.io/unfinished-bench/

## CarryOn: Learning What to Keep in Context for Long-Horizon LLM Agents

DevFeed: [CarryOn: Learning What to Keep in Context for Long-Horizon LLM Agents](<https://devfeed.tech/articles/carryon-learning-what-to-keep-in-context-for-long-horizon-llm-agents-135121.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.17808>)

Author: Lihuan Li, Ruiyi Yang, Jiru Wang, Yifan Duan, Xiachong Lin, Hao Xue, Yang Song, Flora Salim

Published: 2026-11-16T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [long-running](<https://devfeed.tech/topics/long-running.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [agents](<https://devfeed.tech/tags/agents.md>), [context](<https://devfeed.tech/tags/context.md>), [context-management](<https://devfeed.tech/tags/context-management.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [learning](<https://devfeed.tech/tags/learning.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [retention](<https://devfeed.tech/tags/retention.md>), [selection](<https://devfeed.tech/tags/selection.md>)

### AI overview

CarryOn pairs compact execution state with fine-grained, source-linked evidence to manage long interaction histories for LLM agents. A learned selector and adaptive retention policy preserve relevant details without extra LLM calls for context management. The paper evaluates task success alongside resource use with Sα and normalized cost per success (NCS). Across AppWorld, OfficeBench, and Tau2 Telecom using three LLM Actors, CarryOn reports 75.7% macro-averaged task success--6.7 percentage points above the strongest baseline--and the best average scores on both metrics.

### Source excerpt

arXiv:2611.17808v1 Announce Type: cross Abstract: Long-horizon LLM agents can coordinate tools and applications to complete complex, multi-step tasks. As their interaction histories grow, effective context management becomes essential for reliable and efficient execution. Existing methods reduce context through summarization, pruning, or history selection. However, shorter contexts do not necessarily support better decisions: summaries can omit exact details needed for later actions, while retaining entire interactions can carry substantial irrelevant information. We propose CarryOn, a lightweight context manager that pairs compact execution state with fine-grained, source-linked evidence. A learned selector and adaptive retention policy keep relevant evidence available without additional LLM calls for context management. We introduce two complementary evaluation metrics: $S_\alpha$ prioritizes task success while accounting for resource use, and normalized cost per success (NCS) measures the resources spent per successful task. Across AppWorld, OfficeBench, and Tau2 Telecom with three LLM Actors, CarryOn achieves 75.7% macro-averaged task success, exceeding the strongest baseline by 6.7 percentage points. It also achieves the best average scores on both metrics.

## Four conditions for composing plugin-based agents without a host agents

DevFeed: [Four conditions for composing plugin-based agents without a host agents](<https://devfeed.tech/articles/four-conditions-for-composing-plugin-based-agents-without-a-host-agents-131964.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2608.28553>)

Author: Hanzhang Jia, Liheng Zeng, Hao Cheng, Yi Gao, Bo Ma, Guolong Xu

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [Service fabric](<https://devfeed.tech/topics/service-fabric.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [all](<https://devfeed.tech/tags/all.md>), [assembly](<https://devfeed.tech/tags/assembly.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [bus](<https://devfeed.tech/tags/bus.md>), [calculus](<https://devfeed.tech/tags/calculus.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ma](<https://devfeed.tech/tags/cs-ma.md>), [death](<https://devfeed.tech/tags/death.md>), [execution](<https://devfeed.tech/tags/execution.md>), [formal](<https://devfeed.tech/tags/formal.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [keep](<https://devfeed.tech/tags/keep.md>), [language-model](<https://devfeed.tech/tags/language-model.md>), [large-language-model](<https://devfeed.tech/tags/large-language-model.md>), [logos](<https://devfeed.tech/tags/logos.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [model](<https://devfeed.tech/tags/model.md>), [plugin](<https://devfeed.tech/tags/plugin.md>)

### AI overview

The paper proposes four conditions for running plugin-based agents without a host process: place state independently, use process-independent record carriers, coordinate recovery, and resolve providers across processes. Its Logos SDK applies these conditions using peer processes and an append-only record carrier. In tests with one fault across 197 realized tasks, a single-process reference lost all sessions, while an MCP configuration preserved sessions but made 1,212 wasted calls. Logos preserved every session, made no wasted calls, lost no records, and maintained task performance. The excerpt says the conditions have formal support and that removing any one makes the assembly require a host again.

### Source excerpt

arXiv:2608.28553v5 Announce Type: replace Abstract: Large language model agents now run long-horizon, multi-tool, autonomous sessions, and the infrastructure must keep the current assembly of capabilities, the progress of execution, and the basis for recovery after a fault. A single-process host holds this information in its own running state, so its death takes the session record and the assembly with it. This paper gives four conditions under which a plugin-based agent needs no host process, one each on state placement, record carriers, recovery coordination, and provider resolution. The store, writer, and delivery disciplines keep the conditions in force, and each carries formal support from the spatiotemporal-composability calculus and from the proofs in the supplementary materials. An agent that meets them can be constructed with its assembly on a bus of peer processes and its record in an append-only carrier owned by no process, and removing any one part makes the assembly need a host again. The conditions themselves are the contribution, and every implementation that meets them inherits the same advantages. Such an agent keeps its session through the death of any process, wastes no calls after a fault, loses no records, recovers locally, changes its capability set while it runs, and carries its undo semantics across processes. This paper builds one SDK of the conditions, Logos, and measures whether it fulfills their promise against the single-process reference and a configuration over MCP under one fault in each of 200 tasks, realized in 197. The reference lost all 197 faulted sessions, the MCP configuration kept its sessions but issued 1,212 wasted calls, and the SDK kept every session, wasted no call, lost no record, and fulfilled the promise of the conditions in every faulted task, with task performance preserved. The conditions give builders a tested route from single-process hosts to peer processes.

## MEME: Multi-entity & Evolving Memory Evaluation

DevFeed: [MEME: Multi-entity & Evolving Memory Evaluation](<https://devfeed.tech/articles/meme-multi-entity-evolving-memory-evaluation-132785.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2605.12477>)

Author: Seokwon Jung, Alexander Rubinstein, Arnas Uselis, Sangdoo Yun, Seong Joon Oh

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [memory](<https://devfeed.tech/tags/memory.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [retrieval](<https://devfeed.tech/tags/retrieval.md>)

### AI overview

MEME evaluates persistent-agent memory across six tasks combining multiple entities and changing information, including Cascade and Absence dependency reasoning and Deletion after removal. Across six memory systems and 100 controlled episodes, default dependency-reasoning accuracy was very low (3% for Cascade and 1% for Absence), despite adequate static retrieval. Prompt tuning, deeper retrieval, less filler, and most stronger LLMs did little to close the gap. A file-based agent using Claude Opus 4.7 improved results partially, at roughly 70 times baseline cost.

### Source excerpt

arXiv:2605.12477v2 Announce Type: replace Abstract: LLM-based agents increasingly operate in persistent environments where they must store, update, and reason over information across many sessions. While prior benchmarks evaluate only single-entity updates, MEME defines six tasks spanning the full space defined by the multi-entity and evolving axes, including three not scored by prior work: Cascade and Absence (dependency reasoning) and Deletion (post-removal state). Evaluating six memory systems spanning three memory paradigms on 100 controlled episodes, we find that all systems collapse on dependency reasoning under the default configuration (Cascade: 3%, Absence: 1% in average accuracy) despite adequate static retrieval performance. Prompt optimization, deeper retrieval, reduced filler noise, and most stronger LLMs fail to close this gap. The largest gain comes from a file-based agent paired with Claude Opus 4.7 as its internal LLM, which partially closes the gap at roughly 70x the baseline cost. Code and data are available on the project page: https://seokwonjung-jay.github.io/meme-eval/

## When Should Agents Remember? Falsification-Gated Self-Evolution for LLM Agents

DevFeed: [When Should Agents Remember? Falsification-Gated Self-Evolution for LLM Agents](<https://devfeed.tech/articles/when-should-agents-remember-falsification-gated-self-evolution-for-llm-agents-128420.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.14326>)

Author: Runxuan Tang, Haoyu Gao, Yuyan Ding, Junyi Yao, Zihao Zheng, Zecheng Sheng, Liwei Hou

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [agent-state](<https://devfeed.tech/tags/agent-state.md>), [agents](<https://devfeed.tech/tags/agents.md>), [announce](<https://devfeed.tech/tags/announce.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [framework](<https://devfeed.tech/tags/framework.md>), [hypothesis](<https://devfeed.tech/tags/hypothesis.md>), [improvement](<https://devfeed.tech/tags/improvement.md>), [knowledge](<https://devfeed.tech/tags/knowledge.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [memory](<https://devfeed.tech/tags/memory.md>), [performance](<https://devfeed.tech/tags/performance.md>), [precondition](<https://devfeed.tech/tags/precondition.md>), [regression](<https://devfeed.tech/tags/regression.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tool-use](<https://devfeed.tech/tags/tool-use.md>), [update](<https://devfeed.tech/tags/update.md>), [web](<https://devfeed.tech/tags/web.md>)

### AI overview

Falsification-Gated Self-Evolution (FGSE) treats experience-derived agent updates as hypotheses to test before adding them to persistent memory. Each hypothesis specifies a precondition, behavior change, expected effect, and verifier; FGSE applies it temporarily, probes target transfer, falsification, and archived regression, then commits, refines, or rejects it based on measured gain and risk. Across web, app, tool-use, and long-term-memory benchmarks, the paper reports 39.8 WebArena success, 78.8 AppWorld average completion, and Pass^1 scores of 0.724 on τ-Retail and 0.487 on τ-Airline. It also reports 5.0% falsification failures, 1.3% regression damage, and 3.6% harmful committed updates. These abstract-level results suggest hypothesis testing can support more reliable long-term adaptation.

### Source excerpt

arXiv:2611.14326v1 Announce Type: new Abstract: LLM agents increasingly operate in long-horizon, verifier-rich environments, but current self-improvement mechanisms often write episode-derived lessons directly into memory, making local success an unreliable signal for reusable and safe knowledge. This paper addresses the core question of when an experience-derived behavioral update should be admitted into persistent agent state. We propose Falsification-Gated Self-Evolution (FGSE), a verifier-grounded framework that represents each candidate lesson as a structured hypothesis with an explicit precondition, behavior change, expected effect, and verifier. FGSE applies the hypothesis only in a temporary state, tests it on target-transfer, falsification, and archived-regression probes, and then commits, refines, or rejects it according to measured gain and risk. Across web, app, tool-use, and long-term memory benchmarks, FGSE achieves strong task performance, including 39.8 WebArena success rate, 78.8 AppWorld average completion, and 0.724/0.487 Pass$^1$ on $\tau$-Retail/$\tau$-Airline, while reducing falsification failures to 5.0%, regression damage to 1.3%, and harmful committed updates to 3.6%. These results suggest that testing memory updates as hypotheses supports more reliable long-term adaptation.

## Long-horizon agents and durable execution

DevFeed: [Long-horizon agents and durable execution](<https://devfeed.tech/articles/long-horizon-agents-and-durable-execution-128970.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/durable-execution-agents.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-11-10T14:10:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [long-running](<https://devfeed.tech/topics/long-running.md>), [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [automate](<https://devfeed.tech/tags/automate.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [can](<https://devfeed.tech/tags/can.md>), [complete](<https://devfeed.tech/tags/complete.md>), [complex](<https://devfeed.tech/tags/complex.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [days](<https://devfeed.tech/tags/days.md>), [durable-execution](<https://devfeed.tech/tags/durable-execution.md>), [execution](<https://devfeed.tech/tags/execution.md>), [external](<https://devfeed.tech/tags/external.md>), [failure](<https://devfeed.tech/tags/failure.md>), [failures](<https://devfeed.tech/tags/failures.md>), [helps](<https://devfeed.tech/tags/helps.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [model](<https://devfeed.tech/tags/model.md>), [more](<https://devfeed.tech/tags/more.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [network](<https://devfeed.tech/tags/network.md>), [pattern](<https://devfeed.tech/tags/pattern.md>)

### AI overview

Durable execution lets long-running agents recover from crashes by logging each external step's inputs and results, replaying the program to rebuild state, and skipping completed steps. Temporal and Cloudflare Workflows both support durable steps and waits; the article's code uses Temporal, while Cloudflare uses `step.do` and `step.waitForEvent`. Retries are at least once, so writes need stable idempotency keys to avoid duplicates. The harness must also handle uncertain outcomes, stale approvals and changing prices, code changes during suspended workflows, growing memory, and untrusted text. The article contrasts runtime behavior during rule changes: Temporal continued an existing task under its earlier rule, while Cloudflare failed when replayed decisions violated current rules. It recommends versioning rules and treating the log as a published interface. Durable execution supports recovery, but does not ensure decisions are correct or secure.

### Source excerpt

Long-horizon agents can automate complex tasks that take days or weeks to complete and involve multiple exchanges with people and external systems. Many things can go wrong during this time, including process crashes, network failures, and unanticipated real-world behavior. Kiran Prakash explains durable execution: an emerging pattern that helps agents recover from these failures and move towards their goal. In this programming model, the runtime keeps a record of the result of each step that interacts with the outside world so that, when a failure occurs, the program runs again, completed steps are skipped, and the program's state is rebuilt from the record. more...

## Who needs workflows when you have agents?

DevFeed: [Who needs workflows when you have agents?](<https://devfeed.tech/articles/who-needs-workflows-when-you-have-agents-128938.md>)

Original publisher: [Read original article](<https://temporal.io/blog/who-needs-workflows-when-you-have-agents>)

Author: Tao Guo

Published: 2026-11-10T00:00:00Z

Content type: opinion

Language: en

Sources: [Temporal](<https://devfeed.tech/sources/temporal-blog.md>)

Topics: [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [about](<https://devfeed.tech/tags/about.md>), [accounts-payable](<https://devfeed.tech/tags/accounts-payable.md>), [actions](<https://devfeed.tech/tags/actions.md>), [adapting](<https://devfeed.tech/tags/adapting.md>), [adaptive](<https://devfeed.tech/tags/adaptive.md>), [after](<https://devfeed.tech/tags/after.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-orchestration](<https://devfeed.tech/tags/agent-orchestration.md>), [agents](<https://devfeed.tech/tags/agents.md>), [auditability](<https://devfeed.tech/tags/auditability.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [gives](<https://devfeed.tech/tags/gives.md>), [long-running](<https://devfeed.tech/tags/long-running.md>), [needs](<https://devfeed.tech/tags/needs.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [running](<https://devfeed.tech/tags/running.md>), [temporal](<https://devfeed.tech/tags/temporal.md>), [temporal-voices](<https://devfeed.tech/tags/temporal-voices.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

The article argues that enterprise agents can remain adaptive while deterministic workflows handle exact business transactions, with Temporal providing durable execution between them. It says Temporal preserves workflow state and audit history, manages retries and recovery across failures, and lets processes resume through long pauses, restarts, and human approvals. Temporal Nexus connects agents and workflows through service contracts in both directions, including work that completes hours or days later. In the accounts payable example, an agent reviews invoices and prepares a batch, while a Temporal Workflow executes and monitors approved payments, resuming after provider outages or redeployments. The article presents this as an architectural approach for reliability and auditability; it does not provide comparative performance measurements.

### Source excerpt

See how Temporal gives AI agents a durable backbone for long-running enterprise workflows that require reliability, recovery, and auditability.

## Perplexity's AI agents keep working after you close the tab

DevFeed: [Perplexity's AI agents keep working after you close the tab](<https://devfeed.tech/articles/perplexity-s-ai-agents-keep-working-after-you-close-the-tab-122595.md>)

Original publisher: [Read original article](<https://thenewstack.io/perplexity-teammates-agent-orchestration/>)

Author: Amanda Caswell

Published: 2026-11-08T15:30:00Z

Content type: news

Language: en

Sources: [The New Stack](<https://devfeed.tech/sources/the-new-stack.md>)

Topics: [long-running](<https://devfeed.tech/topics/long-running.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [human in the loop agent](<https://devfeed.tech/topics/human-in-the-loop-agent.md>)

Tags: [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-infrastructure](<https://devfeed.tech/tags/ai-infrastructure.md>), [ai-operations](<https://devfeed.tech/tags/ai-operations.md>), [autonomy](<https://devfeed.tech/tags/autonomy.md>), [brain](<https://devfeed.tech/tags/brain.md>), [btrfs](<https://devfeed.tech/tags/btrfs.md>), [computer](<https://devfeed.tech/tags/computer.md>), [credentials](<https://devfeed.tech/tags/credentials.md>), [encryption](<https://devfeed.tech/tags/encryption.md>), [firecracker](<https://devfeed.tech/tags/firecracker.md>), [git](<https://devfeed.tech/tags/git.md>), [github](<https://devfeed.tech/tags/github.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [ios](<https://devfeed.tech/tags/ios.md>), [isolated-environment](<https://devfeed.tech/tags/isolated-environment.md>), [latency](<https://devfeed.tech/tags/latency.md>), [max](<https://devfeed.tech/tags/max.md>), [memory](<https://devfeed.tech/tags/memory.md>), [permissions](<https://devfeed.tech/tags/permissions.md>), [perplexity](<https://devfeed.tech/tags/perplexity.md>)

### AI overview

Perplexity Teammates lets agents continue work across sessions by separating persistent project state from individual execution environments. Agents work in separate sandboxes and submit changes to a shared Git-backed project repository; Perplexity reports that fewer than 2% of submissions are rejected for outdated state, with median submission latency under 1.7 seconds and p99 under eight seconds. Its Brain system stores shared agent knowledge separately, while SPACE uses Firecracker microVMs and Btrfs snapshots to pause, resume, or fork sessions. Users can connect tools such as Slack and GitHub, configure triggers, monitor progress, and take control. The excerpt leaves open how permission boundaries are enforced during handoffs and how agents handle blocked or stale work. Teammates is available on the web to Perplexity Max subscribers; iOS support is planned.

### Source excerpt

Perplexity's new Teammates can coordinate multiple agents, remember where previous sessions left off, and keep working without another prompt. The The post Perplexity's AI agents keep working after you close the tab appeared first on The New Stack.

## openJiuwen: Beyond Static Harnesses for Long-Horizon Coding Agents

DevFeed: [openJiuwen: Beyond Static Harnesses for Long-Horizon Coding Agents](<https://devfeed.tech/articles/openjiuwen-beyond-static-harnesses-for-long-horizon-coding-agents-120078.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2608.27969>)

Author: Tao Yu, Xinyu Zhang, Qianqian Chen, Xiaoneng Xiang, Chia Kwangyang, Xingchen Huang, Ran Chen, Yangkai Ding, Zheng Wang, Yeo Boon Hong, Bingzheng Gan, Enrui Hu, Shuo Cheng, Deyang Li, Ruifeng Shi, Hong

Published: 2026-11-06T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [long-running](<https://devfeed.tech/topics/long-running.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [agent-harness](<https://devfeed.tech/tags/agent-harness.md>), [agent-harnesses](<https://devfeed.tech/tags/agent-harnesses.md>), [agents](<https://devfeed.tech/tags/agents.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [coding-tasks](<https://devfeed.tech/tags/coding-tasks.md>), [composability](<https://devfeed.tech/tags/composability.md>), [context](<https://devfeed.tech/tags/context.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [diagnostics](<https://devfeed.tech/tags/diagnostics.md>), [execution](<https://devfeed.tech/tags/execution.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [flow](<https://devfeed.tech/tags/flow.md>), [framework](<https://devfeed.tech/tags/framework.md>), [harness](<https://devfeed.tech/tags/harness.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [performance](<https://devfeed.tech/tags/performance.md>), [policy](<https://devfeed.tech/tags/policy.md>)

### AI overview

openJiuwen is an open-source harness for long-horizon coding agents that combines composable execution with runtime adaptation. Its shared execution substrate and Rail-based capability composition support single agents, delegated sub-agents, and Swarm Flow under common execution semantics. The harness adjusts framework-controlled context, feedback, and task-control decisions as diagnostics, execution outcomes, progress, and context relevance change, while keeping model policy fixed. In reported evaluations, it scored 82.6% on SWE-bench Verified and 87.19% on Terminal-Bench 2.1, exceeding the strongest selected official-leaderboard point estimates by 3.4 and 3.39 percentage points, respectively. The supplied abstract does not describe evaluation methods or limitations.

### Source excerpt

arXiv:2608.27969v2 Announce Type: replace Abstract: Long-horizon coding agents operate over evolving repository states while increasingly relying on heterogeneous capabilities, delegated agents, and multi-agent coordination. These trends pose two complementary challenges for the agent harness. First, developers need to compose capabilities, reconfigure execution logic, and scale increasingly complex agent systems without repeatedly rebuilding orchestration. Second, complex coding tasks continuously produce new evidence---such as semantic diagnostics, execution outcomes, task progress, and changing context relevance---that should dynamically influence subsequent runtime decisions. We characterize these challenges as Structural Composability and Runtime Adaptivity. We present openJiuwen, an open-source harness designed for both developer composability and adaptive task execution. openJiuwen provides a shared execution substrate and Rail-based capability composition across single agents, delegated sub-agents, and Swarm Flow, enabling developers to construct sophisticated agent harnesses under common execution semantics. It further adapts framework-controlled runtime decisions around a fixed model policy, allowing evolving evidence to dynamically affect context, feedback, and task control toward successful completion. We systematically evaluate openJiuwen on SWE-bench Verified and Terminal-Bench 2.1, where it achieves 82.6% and 87.19%, respectively, exceeding the strongest selected official-leaderboard point estimates by 3.4 and 3.39 percentage points. These results show that openJiuwen achieves strong performance on complex coding tasks while providing a composable and adaptive harness design.

## Kiro introduces Kiro Bots, goal-oriented agents

DevFeed: [Kiro introduces Kiro Bots, goal-oriented agents](<https://devfeed.tech/articles/kiro-introduces-kiro-bots-goal-oriented-agents-119539.md>)

Original publisher: [Read original article](<https://sdtimes.com/agentic-ai/kiro-introduces-kiro-bots-goal-oriented-agents/>)

Author: David Rubinstein

Published: 2026-11-05T19:00:44Z

Content type: release

Language: en

Sources: [SD Times](<https://devfeed.tech/sources/sd-times.md>)

Topics: [Kiro](<https://devfeed.tech/topics/kiro.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [human in the loop agent](<https://devfeed.tech/topics/human-in-the-loop-agent.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-engineering](<https://devfeed.tech/tags/agentic-engineering.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [ai-assisted-development](<https://devfeed.tech/tags/ai-assisted-development.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [artificial-intelligence-agents](<https://devfeed.tech/tags/artificial-intelligence-agents.md>), [availability](<https://devfeed.tech/tags/availability.md>), [bots](<https://devfeed.tech/tags/bots.md>), [context](<https://devfeed.tech/tags/context.md>), [developers](<https://devfeed.tech/tags/developers.md>), [development](<https://devfeed.tech/tags/development.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [general-availability](<https://devfeed.tech/tags/general-availability.md>), [goal-oriented-agents](<https://devfeed.tech/tags/goal-oriented-agents.md>), [kiro](<https://devfeed.tech/tags/kiro.md>), [kiro-crew](<https://devfeed.tech/tags/kiro-crew.md>), [latest-news](<https://devfeed.tech/tags/latest-news.md>), [long-running](<https://devfeed.tech/tags/long-running.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [teams](<https://devfeed.tech/tags/teams.md>)

### AI overview

Kiro Bots are long-running, named agents in Kiro Crew, built around persistent, isolated memory and tailored workspaces to reduce the coordination burden of fragmented AI sessions. Each bot has inspectable notes, a chat stream, and a dashboard; it can delegate parallel work, track and redirect workers, and ask for human judgment on one task while continuing others. Bots can also run on schedules. Permissions and roles are scoped: examples include research bots with read-only access and code review bots that comment without approval or merge authority; deployment and release tasks require developer sign-off for changes or shipping. Developers can assign different models to bots and workers, and run them locally or on Mac Minis or cloud EC2 instances. The excerpt says Kiro Bots are generally available within Kiro Crew.

### Source excerpt

In a major development for software engineering teams, Kiro has officially announced the general availability of Kiro bots within Kiro Crew. The release introduces named, long-running artificial intelligence agents designed to restructure how agentic engineering work is driven and structured. Rather than forcing developers to manage fragmented, short-lived task sessions, Kiro bots provide dedicated agents... ... continue reading The post Kiro introduces Kiro Bots, goal-oriented agents appeared first on SD Times.

## Introducing DigitalOcean Cuttlefish: Get more done with agents on the go

DevFeed: [Introducing DigitalOcean Cuttlefish: Get more done with agents on the go](<https://devfeed.tech/articles/introducing-digitalocean-cuttlefish-get-more-done-with-agents-on-the-go-119686.md>)

Original publisher: [Read original article](<https://www.digitalocean.com/blog/introducing-cuttlefish>)

Author: DigitalOcean

Published: 2026-11-05T14:05:00Z

Content type: release

Language: en

Sources: [DigitalOcean](<https://devfeed.tech/sources/digitalocean.md>)

Topics: [human in the loop agent](<https://devfeed.tech/topics/human-in-the-loop-agent.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [cuttlefish](<https://devfeed.tech/tags/cuttlefish.md>), [digitalocean](<https://devfeed.tech/tags/digitalocean.md>), [digitalocean-managed-agents](<https://devfeed.tech/tags/digitalocean-managed-agents.md>), [face-id](<https://devfeed.tech/tags/face-id.md>), [iphone](<https://devfeed.tech/tags/iphone.md>), [product-updates](<https://devfeed.tech/tags/product-updates.md>)

### AI overview

DigitalOcean Cuttlefish is a native iPhone app for monitoring and steering Managed Agents running in isolated cloud sandboxes, so sessions can continue after a user leaves their computer. It streams session activity and alerts users when runs need approval, finish, or fail. Users can inspect full commands, file paths, or diffs before approving or denying tool calls; high-risk requests require Face ID or a passcode. The app also lets users send guidance during a run (queued for later), pause, resume, or stop sessions, view generated websites and documents, browse workspace files, create checkpoints, and fork or roll back. Managed Agents are described as in Public Preview; the supplied excerpt ends before completing its explanation of the principles behind the product.

### Source excerpt

Your agent has been refactoring for two hours. It's deep in the codebase, making real progress, and then it stops: "Can I run this migration?" Nothing happens until you answer. And you're not at your desk. You're in line at the grocery store, or waiting at school pickup. DigitalOcean Managed Agents, in Public Preview, already moved your agents off your laptop and into the cloud. Each session runs in its own isolated sandbox, so the work keeps going after you close the lid. Now the person in the loop can be anywhere too. Today we're introducing Cuttlefish, a native iPhone app for Managed Agents. From your phone, you can review what an agent found, add the context only you have, approve the next step, or start new work. Then you put your phone away and get on with your day. Keep up with agents that never clock out Agents run for minutes, hours, or overnight, and they stop to ask for permission along the way. Cuttlefish is built for those moments: Follow live sessions: Watch replies, reasoning, and tool calls stream in, and get notified when a run needs approval, finishes, or fails. Approve or deny tool calls: See the full command, file path, or diff, rather than a summary, and unblock your agent from wherever you are. Requests classified as high risk require Face ID or your passcode. Steer mid-run: Send a correction, pause, resume, or stop a session when it's heading the wrong way. Messages you send while the agent works get queued, so you can line up the next task without waiting. Work with the results: View what your agent built, including websites and documents, right in the app. Cuttlefish attaches to running servers and presents the content in a format suited to quick viewing. You can also browse workspace files, create checkpoints, and fork or roll back. Built on three principles: choice, control, and collaboration We built Managed Agents around three principles: choice, control, and collaboration. Choice means you pick the right tool for each job, so Managed Ag

## Do agents need to sleep?

DevFeed: [Do agents need to sleep?](<https://devfeed.tech/articles/do-agents-need-to-sleep-118301.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.02216>)

Author: Ido Haber, Giulio Tononi

Published: 2026-11-05T05:00:00Z

Content type: opinion

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [long-running](<https://devfeed.tech/topics/long-running.md>), [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [llamaindex](<https://devfeed.tech/topics/llamaindex.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [continuous](<https://devfeed.tech/tags/continuous.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [digital](<https://devfeed.tech/tags/digital.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [environment](<https://devfeed.tech/tags/environment.md>), [errors](<https://devfeed.tech/tags/errors.md>), [interaction](<https://devfeed.tech/tags/interaction.md>), [learning](<https://devfeed.tech/tags/learning.md>), [llm](<https://devfeed.tech/tags/llm.md>), [memory](<https://devfeed.tech/tags/memory.md>), [plasticity](<https://devfeed.tech/tags/plasticity.md>), [precision](<https://devfeed.tech/tags/precision.md>), [prediction](<https://devfeed.tech/tags/prediction.md>), [problems](<https://devfeed.tech/tags/problems.md>), [q-bio-nc](<https://devfeed.tech/tags/q-bio-nc.md>), [retrieval](<https://devfeed.tech/tags/retrieval.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [semantic-drift](<https://devfeed.tech/tags/semantic-drift.md>), [sessions](<https://devfeed.tech/tags/sessions.md>), [sleep](<https://devfeed.tech/tags/sleep.md>)

### AI overview

The paper argues that persistent LLM agents face memory problems associated with unchecked plasticity: semantic drift, poorer retrieval, stored errors, and capacity saturation. It maps the three phases of the selectionist "ringing, resonance and renormalization" account of sleep to operations feasible in digital memory architectures. From this analogy, it predicts that selectionist memory consolidation will outperform instructionist alternatives as memory stores grow large. This is presented as a falsifiable prediction; the supplied abstract does not report comparative test results.

### Source excerpt

arXiv:2611.02216v2 Announce Type: cross Abstract: LLM-based agents, which increasingly operate persistently across sessions and accumulate memory through interaction, already exhibit the familiar symptoms of unchecked plasticity: semantic drift, degraded retrieval precision, propagation of stored errors, and saturation of memory capacity. Drawing on the selectionist "ringing, resonance and renormalization" (RRR) account of sleep, we propose that each of its three phases maps onto an operation feasible in digital memory architectures. Engineers building stateful agents, meanwhile, are independently rediscovering the problems sleep evolved to solve: what to forget, and when to do the forgetting. From this we derive the falsifiable prediction that selectionist consolidation will outperform instructionist alternatives as memory stores grow large. The core claim concerns the nature of continuous learning itself: plasticity has a price, and for any system that learns continuously under finite capacity while coupled to its environment, that price is sleep.

## Introducing Render Sandboxes | Render

DevFeed: [Introducing Render Sandboxes | Render](<https://devfeed.tech/articles/introducing-render-sandboxes-render-118952.md>)

Original publisher: [Read original article](<https://render.com/blog/introducing-render-sandboxes>)

Published: 2026-11-04T16:00:00Z

Content type: release

Language: en

Sources: [Render](<https://devfeed.tech/sources/render.md>)

Topics: [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [virtualization](<https://devfeed.tech/topics/virtualization.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [about](<https://devfeed.tech/tags/about.md>), [after](<https://devfeed.tech/tags/after.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-harness](<https://devfeed.tech/tags/agent-harness.md>), [agents](<https://devfeed.tech/tags/agents.md>), [all](<https://devfeed.tech/tags/all.md>), [allowed](<https://devfeed.tech/tags/allowed.md>), [also](<https://devfeed.tech/tags/also.md>), [api](<https://devfeed.tech/tags/api.md>), [api-key](<https://devfeed.tech/tags/api-key.md>), [api-keys](<https://devfeed.tech/tags/api-keys.md>), [beta](<https://devfeed.tech/tags/beta.md>), [environment](<https://devfeed.tech/tags/environment.md>), [linux](<https://devfeed.tech/tags/linux.md>), [public](<https://devfeed.tech/tags/public.md>), [public-beta](<https://devfeed.tech/tags/public-beta.md>), [quickly](<https://devfeed.tech/tags/quickly.md>), [render](<https://devfeed.tech/tags/render.md>), [sandboxes](<https://devfeed.tech/tags/sandboxes.md>)

### AI overview

Render Sandboxes are in public beta, providing isolated Linux Firecracker microVMs for agent tasks. They can run indefinitely and are typically ready for a first command in under a second; idle sandboxes can snapshot and suspend, then wake on the next command. Filesystem snapshots preserve files and tools, while runtime snapshots also preserve memory and processes and are said to make startup 3-10 times faster. Users can set outbound network policies and, where enabled, use credential brokering to keep API keys outside the sandbox; credential brokering and scoped API keys are in early access. Billing covers actively used CPU and allocated memory while running, and snapshot storage while suspended. Sandboxes work with any agent harness and model, are available in Oregon on all workspace plans, and can be managed through the TypeScript or Python SDKs or Render CLI. Private networking, more regions, SSH access, public URLs, resource bursting, and shared filesystems are listed as planned.

### Source excerpt

Render Sandboxes are now in public beta. Give each agent an isolated Linux environment that starts quickly, runs indefinitely, and suspends when idle.

## Rethinking AI Cloud Infrastructure for Agentic Serving Systems with the Aries Experimentation Framework

DevFeed: [Rethinking AI Cloud Infrastructure for Agentic Serving Systems with the Aries Experimentation Framework](<https://devfeed.tech/articles/rethinking-ai-cloud-infrastructure-for-agentic-serving-systems-with-the-aries-experimentation-framework-116467.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2607.29069>)

Author: Jooyoung Park, Leonid Kondrashov, Boxi Zhou, Hongrui Liu, Zonghao Liu, Chengzhi Lu, Riccardo Mancini, Esha Choukse, Haris Javaid, German Sviridov, Tao Peng, Chen Zhao, Anastasia Avdeeva, Aleksei Gusev

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Infrastructure as a Service (IaaS)](<https://devfeed.tech/topics/infrastructure-as-a-service-iaas.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [adaptive](<https://devfeed.tech/tags/adaptive.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-harnesses](<https://devfeed.tech/tags/agent-harnesses.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-cloud](<https://devfeed.tech/tags/ai-cloud.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-infrastructure](<https://devfeed.tech/tags/cloud-infrastructure.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [experimentation](<https://devfeed.tech/tags/experimentation.md>), [framework](<https://devfeed.tech/tags/framework.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [serving](<https://devfeed.tech/tags/serving.md>), [systems](<https://devfeed.tech/tags/systems.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

Aries supports reproducible, full-stack experiments on agent serving by separating task specifications from execution configurations, correlating system telemetry across agent trajectories, and providing a consistent interface to stateful tools across sandbox substrates. The authors combine experiments on open harnesses and benchmarks with production traces from a commercial platform. They report that token-centric metrics miss non-inference bottlenecks; retaining more context brings diminishing accuracy gains while reducing serving capacity; and sandbox workloads alternate between long idle periods and short bursts, while snapshot-based state management makes aggressive suspension costly. They propose agent-native serving built around trajectory-level metrics, adaptive context management, and elastic sandbox resources.

### Source excerpt

arXiv:2607.29069v2 Announce Type: replace Abstract: Autonomous agents challenge conventional LLM serving with long-lived, cross-component execution and evolving system state. These characteristics complicate controlled systems experimentation and attribution of end-to-end behavior across the serving stack. We present Aries, a full-stack experimentation framework that separates task specifications from execution configurations, reconstructs cross-component agent trajectories with correlated system telemetry, and exposes stateful tool execution through a consistent interface across heterogeneous sandbox substrates. We use Aries to conduct reproducible experiments on open agent harnesses and benchmarks. We complement these experiments with production traces from a commercial platform, grounding low-level systems research in observed production behavior. Our results show that (1) token-centric metrics miss non-inference bottlenecks, (2) retaining additional context yields diminishing accuracy benefits while reducing serving capacity, and (3) tool sandboxes alternate between long idle periods and short resource bursts, while current snapshot-based state management makes aggressive suspension costly. We then discuss the vision for agent-native serving systems designed around trajectory-level metrics, adaptive context management, and elastic sandbox resource management.

## Meta$^2$: Precomputing Reusable Knowledge for Online Harness Evolution in Long-Horizon Agents

DevFeed: [Meta$^2$: Precomputing Reusable Knowledge for Online Harness Evolution in Long-Horizon Agents](<https://devfeed.tech/articles/meta-2-precomputing-reusable-knowledge-for-online-harness-evolution-in-long-horizon-agents-117567.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.05139>)

Author: Lingzhi Yuan, Yiguang Cai, Weize Liu, Siqi Yang, Feijiang Han, Yongkyun Lee, Udari Madhushani Sehwag, Furong Huang

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [knowledge-engineering](<https://devfeed.tech/topics/knowledge-engineering.md>), [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>), [long-running](<https://devfeed.tech/topics/long-running.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [bench](<https://devfeed.tech/tags/bench.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [deepswe](<https://devfeed.tech/tags/deepswe.md>), [deepswe-1-1](<https://devfeed.tech/tags/deepswe-1-1.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [gpt](<https://devfeed.tech/tags/gpt.md>), [gpt-5-6](<https://devfeed.tech/tags/gpt-5-6.md>), [gpt-5-6-terra](<https://devfeed.tech/tags/gpt-5-6-terra.md>), [guidance](<https://devfeed.tech/tags/guidance.md>), [harness](<https://devfeed.tech/tags/harness.md>), [hooks](<https://devfeed.tech/tags/hooks.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [knowledge](<https://devfeed.tech/tags/knowledge.md>), [meta](<https://devfeed.tech/tags/meta.md>), [online](<https://devfeed.tech/tags/online.md>)

### AI overview

Meta$^2$ learns reusable guidance for adapting long-horizon agents' harnesses, rather than training one shared harness for all tasks. Offline, it compares training rollouts under three setups--no evolver, an evolver guided by the current Meta-Skill, and an evolver with verifier information available only during training--to refine guidance on when to edit, keep, or avoid changes. Online, an evolver uses the frozen Meta-Skill and emerging trajectory evidence to KEEP the harness or make a task-local edit that applies for the rest of the run without resetting progress; held-out verifier feedback is unavailable. With GPT-5.6-Terra, the paper reports the highest performance among evaluated methods on Terminal-Bench 2.1 (81.00%) and DeepSWE 1.1 (44.44%). Ablations support contrastive guidance and task-local edits. These claims are limited to the two reported benchmarks and evaluated methods.

### Source excerpt

arXiv:2611.05139v1 Announce Type: new Abstract: Harness optimization improves long-horizon agents by refining the prompts, tools, memory, and hooks around a frozen model. Offline methods can learn from completed trajectories, but deploy one shared harness that may overfit training tasks and cannot react to evidence revealed during a new run. Online evolution can adapt before, during, or after one run through an evolver, but may have to reason about every intervention from scratch or rely on verifier feedback that is usually unavailable at test time. We introduce Meta$^2$, which moves offline optimization one level up: rather than optimizing a shared harness, it learns reusable knowledge for harness evolution and applies it within each task online. Offline, Meta$^2$ learns a textual Meta-Skill $M$ by contrasting training rollouts of the same task agent under three configurations: without an evolver, with an evolver guided by the current version of $M$, and with an evolver given privileged verifier information available only in training. Contrasts in trajectories and outcomes are aggregated across tasks to refine $M$ into reusable guidance on when and how to evolve, when to leave the harness unchanged, and which interventions to avoid. Online, an evolver combines the frozen $M$ with emerging trajectory evidence to decide whether to KEEP the harness unchanged or EVOLVE it through a task-local edit. Each edit applies to the rest of the same run without resetting its environment or progress. Thus, evolution guidance transfers across tasks while harness edits remain task-local, and held-out verifier feedback is never available to the evolver. On two long-horizon benchmarks, Terminal-Bench 2.1 and DeepSWE 1.1, Meta$^2$ achieves the highest performance among evaluated methods with GPT-5.6-Terra, reaching 81.00% and 44.44%, respectively. Ablations support the value of contrastive evolution guidance and keeping online harness edits task-local.

## Durable Execution means deciding what survives failure

DevFeed: [Durable Execution means deciding what survives failure](<https://devfeed.tech/articles/durable-execution-means-deciding-what-survives-failure-117163.md>)

Original publisher: [Read original article](<https://temporal.io/blog/durable-execution-means-deciding-what-survives-failure>)

Author: Muhammad Abu Bakkar Bin Akmal

Published: 2026-11-04T00:00:00Z

Content type: article

Language: en

Sources: [Temporal](<https://devfeed.tech/sources/temporal-blog.md>)

Topics: [Persistence](<https://devfeed.tech/topics/persistence.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [reliability-engineering](<https://devfeed.tech/topics/reliability-engineering.md>), [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [AI Integration Strategies](<https://devfeed.tech/topics/ai-integration-strategies.md>), [ReAct agent Python](<https://devfeed.tech/topics/react-agent-python.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-workflows](<https://devfeed.tech/tags/agent-workflows.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [community](<https://devfeed.tech/tags/community.md>), [durable-execution](<https://devfeed.tech/tags/durable-execution.md>), [failure](<https://devfeed.tech/tags/failure.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [progress](<https://devfeed.tech/tags/progress.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [retries](<https://devfeed.tech/tags/retries.md>), [temporal](<https://devfeed.tech/tags/temporal.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

Temporal can restore Workflow progress after Worker restarts by replaying Event History, but application policy still determines retries, business status, cancellation, and what counts as success. In the Kubernetes scan, six analyzers run concurrently but are awaited in slice order, so failures are not observed fail-fast; the review also flags status cleanup and ambiguous database-record/Workflow-start outcomes. Analysis results are persisted before the optional assessment, allowing them to survive an assessment failure. In the AI recommendation loop, proposals carry prior feedback and budget across rounds, with explicit exits for consensus, approved score, repeated concerns, or round limit. Only accepted decisions should be cached; unresolved results can be structurally valid. The excerpt recommends defining start and ID reuse semantics, making external effects retry-safe through stable keys and deduplication, putting replay-sensitive configuration in Workflow input, and testing business outcomes and Worker-loss recovery. Its reviewed tests did not cover the listed failure scenarios or a live Nexus end-to-end path.

### Source excerpt

See how Temporal preserves progress across failures in Kubernetes analysis and AI agent Workflows, while keeping retries and recovery explicit.

[Next page](<https://devfeed.tech/topics/long-running.md?cursor=WyIyMDI2LTExLTA0VDAwOjAwOjAwKzAwOjAwIiwgIjZkMmU0NDZhLWEzYWEtNDY1Zi04NGFmLTU4MGY1N2FhOGRjYSJd>)