# async

Asynchronous software design allows a program to perform tasks without stopping to wait for them to complete, enabling other work to continue while awaiting results.

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

## Cap-and-Track: Optimizing LLM Inference Request Dispatch Across Shifting Capacity

DevFeed: [Cap-and-Track: Optimizing LLM Inference Request Dispatch Across Shifting Capacity](<https://devfeed.tech/articles/cap-and-track-optimizing-llm-inference-request-dispatch-across-shifting-capacity-143577.md>)

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

Author: Benjamin Novotny, Doug Szeto, Chang Wang, Shicheng Chen, George Zhihua Yuan, Bob Kamma, Michael Ge, John Xin Zhou, Andrea Olgiati

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

Content type: article

Language: en

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

Topics: [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [backpressure](<https://devfeed.tech/topics/backpressure.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [about](<https://devfeed.tech/tags/about.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [admission](<https://devfeed.tech/tags/admission.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [backend](<https://devfeed.tech/tags/backend.md>), [batches](<https://devfeed.tech/tags/batches.md>), [can](<https://devfeed.tech/tags/can.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [change](<https://devfeed.tech/tags/change.md>), [classifier](<https://devfeed.tech/tags/classifier.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [design](<https://devfeed.tech/tags/design.md>), [dispatch](<https://devfeed.tech/tags/dispatch.md>), [dispatcher](<https://devfeed.tech/tags/dispatcher.md>), [inference](<https://devfeed.tech/tags/inference.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-inference](<https://devfeed.tech/tags/llm-inference.md>), [optimizing](<https://devfeed.tech/tags/optimizing.md>), [request](<https://devfeed.tech/tags/request.md>)

### AI overview

Cap-and-Track dispatches asynchronous LLM inference using backend refusals as signals of current capacity. Cap rejects work before it incurs a long wait; durable priority queues hold excess and refused requests for retry. Track probes upward and backs off using those refusals, avoiding output-length prediction and a fixed fleet-wide rate. In a same-traffic production A/B, the system served a classifier with 43% fewer H100s than its queued, fixed-rate predecessor, though lower-priority work waited longer during backfill peaks. In steady-capacity engine replay, it achieved within 1% of a fixed rate tuned above capacity, with about one-quarter its refusal share. The authors also recommend keeping engine queues only long enough to fill batches, maintaining stateful dispatch, and sizing fleets according to tolerable waits for low-priority work.

### Source excerpt

arXiv:2611.24891v1 Announce Type: new Abstract: A fixed dispatch rate for LLM inference becomes stale as serving fleets resize and request sizes change. Generative output length is unknown at admission, and shared provider pools can lose capacity. We present Cap-and-Track, a design for asynchronous inference across provider capacity and internal GPUs. Meta's traffic shaper implements Cap-and-Track for post and live-video understanding. Refusals signal the backend's current admission ceiling. Durable priority queues hold excess work outside execution, including refused requests for retry. Cap is a fail-fast admission check at the saturated resource that refuses work before a long wait. Using only those refusals, the Track dispatcher probes upward and backs off. It follows the ceiling without output-length prediction or a fleet-level rate to retune. In a concurrent same-traffic production A/B, the shaper ran per-replica Cap plus Track. It served a classifier on 43% fewer H100s than its queued, fixed-rate precursor, though lower-priority work waited longer at backfill peaks. In steady-capacity real-engine replay, Track ran within 1% of the goodput of a fixed rate tuned above measured capacity, with about a quarter of that rate's refusal share. The shaper carries more than 300 million online requests and hundreds of terabytes of media a day. During a backfill, it handled 1.1 billion requests in its busiest 24 hours. Lessons include keeping queues inside inference engines just long enough to fill batches, steering dispatch by capacity refusals alone, keeping dispatch stateful, and sizing fleets by how long low-priority work can wait.

## Revision-Consistent Code Context for Agents That Edit Their Environment

DevFeed: [Revision-Consistent Code Context for Agents That Edit Their Environment](<https://devfeed.tech/articles/revision-consistent-code-context-for-agents-that-edit-their-environment-139576.md>)

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

Author: Meng Shi

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

Content type: article

Language: en

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

Topics: [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [code search](<https://devfeed.tech/topics/code-search.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [after](<https://devfeed.tech/tags/after.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [all](<https://devfeed.tech/tags/all.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [boundary](<https://devfeed.tech/tags/boundary.md>), [call](<https://devfeed.tech/tags/call.md>), [can](<https://devfeed.tech/tags/can.md>), [code](<https://devfeed.tech/tags/code.md>), [code-intelligence](<https://devfeed.tech/tags/code-intelligence.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [complete](<https://devfeed.tech/tags/complete.md>), [composition](<https://devfeed.tech/tags/composition.md>), [condition](<https://devfeed.tech/tags/condition.md>), [content](<https://devfeed.tech/tags/content.md>), [context](<https://devfeed.tech/tags/context.md>), [contribution](<https://devfeed.tech/tags/contribution.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [environment](<https://devfeed.tech/tags/environment.md>), [revision](<https://devfeed.tech/tags/revision.md>)

### AI overview

The paper proposes a complete-revision publication contract to prevent code-intelligence queries from combining repository facts from different update states. A service must wait, report unavailability, or return a complete old revision before publication; afterward, it returns the complete new revision, with a shared version identity across all views in each response. In Codetrip, which joins source, symbol, and graph facts, this approach produced no unsafe responses in 150 Gin v1.12.0 update trials, compared with two for live-source composition. Journaled, idempotent publication recovered to context equivalent to a clean rebuild in all 300 evaluable trials across frozen Gin and Cobra, with median restart-to-context latency of 77-131 ms. A separate rename probe found mixed context in 0/30 Codetrip trials and 30/30 trials each for CodeGraph and codebase-memory-mcp before clean-full-equivalent convergence. These results are limited to the reported controlled trials.

### Source excerpt

arXiv:2611.21616v1 Announce Type: new Abstract: Editing agents query repositories while simultaneously changing them. Source content, symbols, graph relations, and retrieval state may be maintained by different stores and refreshed at different times. During an update, a successful query can therefore combine facts that never belonged to the same repository state. We call this condition mixed-revision code context. This paper proposes an Agent-visible complete-revision publication contract for composite code-intelligence queries. Before a query-visible publication point, a service must wait, report unavailability, or serve a complete old revision; after that point, it serves the complete new revision. The contract requires a shared version identity and publication boundary across every view returned in one response. We instantiate the method in Codetrip, whose brief operation joins source, symbol, and graph facts. In a controlled comparison on frozen Gin v1.12.0, live-source composition produced two unsafe responses in 150 update trials, whereas complete-revision publication produced none under the same five edit scenarios. We further implement journaled, idempotent publication and terminate the real MCP process at five durable boundaries. All 300 evaluable recovery trials on frozen Gin and Cobra returned complete-new context equivalent to a clean full rebuild, with median restart-to-context latency of 77--131 ms. In a separate rename probe, mixed context occurred in 0/30 Codetrip trials and 30/30 trials for both CodeGraph and codebase-memory-mcp before clean-full-equivalent convergence. The contribution is an Agent-facing safety contract, implementation pattern, and measurement protocol for joining live repository bytes with asynchronously derived facts. Every successful composite response consequently has a testable repository-state meaning, including after interruption.

## AInfer-PD: Communication-Safe In-Place Prefill-Decode Multiplexing for Distributed MoE Rollouts

DevFeed: [AInfer-PD: Communication-Safe In-Place Prefill-Decode Multiplexing for Distributed MoE Rollouts](<https://devfeed.tech/articles/ainfer-pd-communication-safe-in-place-prefill-decode-multiplexing-for-distributed-moe-rollouts-140376.md>)

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

Author: Guowei Wang, Chaokun Yang, Zhenxuan Pan, Yipeng Wei, Yuhong Guo, Minghua Zhu, Zechuan Zhang, Shuo Wan, Xiaowei Zhu

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

Content type: article

Language: en

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

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [async](<https://devfeed.tech/topics/async.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>)

Tags: [ablation](<https://devfeed.tech/tags/ablation.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [batches](<https://devfeed.tech/tags/batches.md>), [collective](<https://devfeed.tech/tags/collective.md>), [communication](<https://devfeed.tech/tags/communication.md>), [completion](<https://devfeed.tech/tags/completion.md>), [continuation](<https://devfeed.tech/tags/continuation.md>), [cross](<https://devfeed.tech/tags/cross.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [d](<https://devfeed.tech/tags/d.md>), [decode](<https://devfeed.tech/tags/decode.md>), [deepep](<https://devfeed.tech/tags/deepep.md>), [devices](<https://devfeed.tech/tags/devices.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [engine](<https://devfeed.tech/tags/engine.md>), [moe](<https://devfeed.tech/tags/moe.md>), [multiplexing](<https://devfeed.tech/tags/multiplexing.md>), [pd](<https://devfeed.tech/tags/pd.md>), [prefill](<https://devfeed.tech/tags/prefill.md>), [safe](<https://devfeed.tech/tags/safe.md>)

### AI overview

AInfer-PD lets decode iterations progress during long prefills in distributed MoE rollouts by coordinating collective ordering across ranks at safe communication boundaries and separating prefill and decode communication buffers and protocol state within one DeepEP runtime. This allows prefills to use DeepEP's normal path while decode keeps its low-latency path, with model weights and KV storage shared on the same devices. In reported prefill-intensive workloads, fixed-workload completion time fell 7.1-22.5% versus the same AInfer engine without P/D multiplexing and 24.8-32.9% versus SGLang on one node; on two nodes, reductions were 18.0-35.3% and 18.3-31.8%, respectively. A same-engine ablation found fine-grained boundaries improved completion time by a further 8.6-19.8% over whole-prefill asynchronous enqueue.

### Source excerpt

arXiv:2609.00993v3 Announce Type: replace Abstract: In agentic reinforcement learning (RL), asynchronous multi-turn trajectories repeatedly introduce continuation prefills (P) while other trajectories remain in decode (D). Efficient rollout completion therefore requires D to advance during long P executions. In-place multiplexing shares devices, model weights, and KV state, but phase-specific communication in distributed MoE introduces two constraints: cross-rank collective ordering and ownership of mutable communication state. Whole-prefill coordination can ensure safe ordering but delays D. DeepEP's normal and low-latency paths suit large P and small D batches, respectively, but safely overlapping them requires separating their mutable communication state. We present AInfer-PD, which extends in-place P/D multiplexing to distributed MoE rollouts. AInfer-PD establishes rank-consistent collective ordering at safe communication boundaries, allowing successive D iterations to advance without waiting for an entire prefill execution to be enqueued or completed. It gives P and D separate communication buffers and protocol state within one DeepEP runtime, allowing P to use the normal path while D retains the low-latency path. Together, these mechanisms preserve useful P/D overlap while sharing model weights and KV storage on the same devices. Across repeated single-node prefill-intensive workloads, AInfer-PD reduces fixed-workload rollout completion time by 7.1-22.5% relative to the same AInfer engine with P/D multiplexing disabled and by 24.8-32.9% relative to SGLang. On two nodes, the reductions are 18.0-35.3% and 18.3-31.8%, respectively. In a same-engine ablation, fine-grained boundaries reduce completion time by a further 8.6-19.8% over whole-prefill asynchronous enqueue.

## AdaFlowLite: Scalable and Non-blocking Inference on Asynchronous Mobile Data

DevFeed: [AdaFlowLite: Scalable and Non-blocking Inference on Asynchronous Mobile Data](<https://devfeed.tech/articles/adaflowlite-scalable-and-non-blocking-inference-on-asynchronous-mobile-data-139897.md>)

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

Author: Sicong Liu, Fengmin Wu, Yuan Gao, Bin Guo, Zimu Zhou, Hongkai Wen, Zhiwen Yu

Published: 2026-11-18T05: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: [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [multimodal-ai](<https://devfeed.tech/topics/multimodal-ai.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [adapting](<https://devfeed.tech/tags/adapting.md>), [adoption](<https://devfeed.tech/tags/adoption.md>), [affinity](<https://devfeed.tech/tags/affinity.md>), [also](<https://devfeed.tech/tags/also.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [approach](<https://devfeed.tech/tags/approach.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [based](<https://devfeed.tech/tags/based.md>), [cabins](<https://devfeed.tech/tags/cabins.md>), [cameras](<https://devfeed.tech/tags/cameras.md>), [can](<https://devfeed.tech/tags/can.md>), [challenge](<https://devfeed.tech/tags/challenge.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [data](<https://devfeed.tech/tags/data.md>), [inference](<https://devfeed.tech/tags/inference.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [mobile-data](<https://devfeed.tech/tags/mobile-data.md>)

### AI overview

AdaFlowLite proposes opportunistic inference for asynchronous mobile sensor data, starting inference as partial inputs arrive to avoid waiting for delayed modalities. It computes cross-modality affinity with a hierarchical, normalized matrix designed to handle varied and changing inputs, then uses a lightweight multimodal Swin Transformer to impute missing data in real time across modalities and downstream tasks without retraining. The abstract reports up to 80.4% lower inference latency, up to 62.1% higher accuracy, and nearly 50% lower energy use than status quo approaches. It also says the method can improve LLM performance when preprocessing asynchronous data; the excerpt gives no further details on that result.

### Source excerpt

arXiv:2611.21691v1 Announce Type: cross Abstract: The rise of mobile devices equipped with numerous sensors, such as LiDAR and cameras, has driven the adoption of multi-modal deep intelligence for distributed sensing tasks, such as smart cabins and driving assistance. However, the arrival time of mobile sensory data vary due to modality size and network dynamics, which can lead to delays (if waiting for slow data) or accuracy decline (if inference proceeds without waiting). Moreover, the diversity and dynamic nature of mobile systems exacerbate this challenge. In response, we present a shift to \textit{opportunistic} inference for asynchronous distributed multi-modal data, enabling inference as soon as partial data arrives. While existing methods focus on optimizing modality consistency and complementarity, known as modal affinity, they lack a \textit{computational} approach to control this affinity in open-world mobile environments. % \sysname pioneers the formulation of structured cross-modality affinity in mobile contexts using a hierarchical analysis-based normalized matrix. This approach accommodates the diversity and dynamics of modalities, generalizing across different types and numbers of inputs. Employing an multi-modal lightweight Swin Transformer (MMLST), \sysname facilitates real-time and flexible data imputation, adapting to various modalities and downstream tasks without retraining. Experiments show that \sysname significantly reduces inference latency by up to 80.4\% and enhances accuracy by up to 62.1\%, while achieving nearly a 50\% reduction in energy consumption, outperforming status quo approaches. Also, this method can enhance LLM performance to preprocess asynchronous data.

## What to know about the Fivetran async provider in Airflow | Blog | Fivetran

DevFeed: [What to know about the Fivetran async provider in Airflow | Blog | Fivetran](<https://devfeed.tech/articles/what-to-know-about-the-fivetran-async-provider-in-airflow-blog-fivetran-140242.md>)

Original publisher: [Read original article](<https://wf.fivetran.com/blog/introducing-the-new-fivetran-async-provider-in-airflow>)

Author: Jimmy Hooker

Published: 2026-11-18T04:07:11Z

Content type: article

Language: en

Sources: [Fivetran Blog](<https://devfeed.tech/sources/fivetran-blog.md>)

Topics: [async](<https://devfeed.tech/topics/async.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [airflow](<https://devfeed.tech/tags/airflow.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [async](<https://devfeed.tech/tags/async.md>), [aws](<https://devfeed.tech/tags/aws.md>), [bigquery](<https://devfeed.tech/tags/bigquery.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [blog](<https://devfeed.tech/tags/blog.md>), [callback](<https://devfeed.tech/tags/callback.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [code](<https://devfeed.tech/tags/code.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [complete](<https://devfeed.tech/tags/complete.md>), [completion](<https://devfeed.tech/tags/completion.md>), [component](<https://devfeed.tech/tags/component.md>), [components](<https://devfeed.tech/tags/components.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [condition](<https://devfeed.tech/tags/condition.md>), [connectors](<https://devfeed.tech/tags/connectors.md>), [data](<https://devfeed.tech/tags/data.md>), [fivetran](<https://devfeed.tech/tags/fivetran.md>)

### AI overview

The Fivetran async provider lets Airflow 2.2+ wait for connector syncs without occupying worker slots. In the standard setup, each `FivetranSensor` holds a worker slot while polling, which can leave other tasks queued. Airflow's triggerer instead monitors deferred tasks asynchronously in a single Python process, then signals the scheduler when the target status is reached. The provider offers `FivetranSensorAsync` to wait for a sync and `FivetranOperatorAsync` to start a sync and monitor it through completion; both are used in DAGs similarly to their standard counterparts. Install it with `pip install airflow-provider-fivetran-async`. The excerpt says examples are available in the provider and Astronomer Registry.

### Source excerpt

Fivetran Airflow provider developed by Astronomer allows data engineers to run Fivetran data syncs more efficiently in Airflow 2.2+

## 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.

## REVISE: Validity-Guided Recovery for Online Revisions in Agent Workflows

DevFeed: [REVISE: Validity-Guided Recovery for Online Revisions in Agent Workflows](<https://devfeed.tech/articles/revise-validity-guided-recovery-for-online-revisions-in-agent-workflows-137276.md>)

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

Author: Ruoling Qi, Xuaner Wu, Penghang Liu, Jian Chen, Yirui Liu

Published: 2026-11-17T05: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>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-workflows](<https://devfeed.tech/tags/agent-workflows.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agent](<https://devfeed.tech/tags/coding-agent.md>), [commit](<https://devfeed.tech/tags/commit.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [dag](<https://devfeed.tech/tags/dag.md>), [data](<https://devfeed.tech/tags/data.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [effects](<https://devfeed.tech/tags/effects.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [execution](<https://devfeed.tech/tags/execution.md>), [impact](<https://devfeed.tech/tags/impact.md>), [langgraph](<https://devfeed.tech/tags/langgraph.md>), [online](<https://devfeed.tech/tags/online.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [revisions](<https://devfeed.tech/tags/revisions.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

Revise recovers from online revisions by tracing each change through recorded data and control dependencies in a partially executed workflow DAG. It stops invalid work, keeps progress judged valid even beyond the earliest conflict, and recomputes only affected work; incomplete provenance expands recovery conservatively, and reused results are revalidated before commit. In 300 challenging revision/commit executions, it matched a latest-version oracle with no stale outputs or effects. On unmodified LangGraph and LLMCompiler applications using Qwen3-14B, it reduced model calls by 40.6-56.0% versus full restart and 31.3-43.6% versus suffix recomputation. Under serving pressure, it cut revision-to-correct-completion tokens by 13.26% and improved SLO goodput by 3.07-5.43%.

### Source excerpt

arXiv:2609.00643v2 Announce Type: replace Abstract: Agent revisions expose a fundamental correctness--efficiency trade-off during concurrent execution. Discarding ongoing work preserves latest-version correctness but wastes progress that may remain valid, whereas reusing prior work preserves efficiency but risks propagating stale state into outputs and tool effects. Existing recovery strategies resolve this trade-off in an imbalanced way with coarse-grained policies: they either favor efficiency by allowing potentially stale work to continue, or favor correctness by restarting the workflow or recomputing a linear suffix from the earliest conflict, thereby discarding unaffected progress. We present \textsc{Revise}, a validity-guided runtime for fine-grained recovery in structured agent workflows. When a revision arrives, \textsc{Revise} first intersects its delta with recorded data and control dependencies and propagates the resulting impact through the partially executed DAG to identify affected work. It then stops invalid work, preserves validity-established progress beyond the earliest conflict, and recomputes only the affected region. Incomplete provenance conservatively expands recovery, while reused results are revalidated before commit. Analysis of real coding-agent traces show online recovery opportunities: 118 sessions retain observable work before a queued later message is delivered; across 167 overlapping assistant responses, enqueue-to-completion overlap reaches 56.55~s at p95. Across 300 challenging revision/commit executions, \textsc{Revise} matches a latest-version oracle with no stale outputs or effects. On unmodified LangGraph and LLMCompiler applications using Qwen3-14B, it reduces model calls by 40.6--56.0\% relative to full restart and by 31.3--43.6\% relative to suffix recomputation. Under serving pressure, it further reduces revision-to-correct-completion tokens by 13.26\% and improves SLO goodput by 3.07--5.43\%.

## Ziggity is a Helpful Tool for Power Users Who Still Use Git Manually

DevFeed: [Ziggity is a Helpful Tool for Power Users Who Still Use Git Manually](<https://devfeed.tech/articles/ziggity-is-a-helpful-tool-for-power-users-who-still-use-git-manually-134587.md>)

Original publisher: [Read original article](<https://feed.itsfoss.com/link/24361/17524990/ziggity-git-client>)

Author: Sreenath

Published: 2026-11-15T11:31:08Z

Content type: article

Language: en

Sources: [It's FOSS](<https://devfeed.tech/sources/it-s-foss.md>)

Topics: [Git](<https://devfeed.tech/topics/git.md>), [Terminal](<https://devfeed.tech/topics/terminal.md>), [async](<https://devfeed.tech/topics/async.md>), [personal access token](<https://devfeed.tech/topics/personal-access-token.md>), [releases](<https://devfeed.tech/topics/releases.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [binaries](<https://devfeed.tech/tags/binaries.md>), [branch](<https://devfeed.tech/tags/branch.md>), [checkout](<https://devfeed.tech/tags/checkout.md>), [client](<https://devfeed.tech/tags/client.md>), [clipboard](<https://devfeed.tech/tags/clipboard.md>), [command](<https://devfeed.tech/tags/command.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [commit](<https://devfeed.tech/tags/commit.md>), [diffs](<https://devfeed.tech/tags/diffs.md>), [git](<https://devfeed.tech/tags/git.md>), [history](<https://devfeed.tech/tags/history.md>), [responsive](<https://devfeed.tech/tags/responsive.md>), [stage](<https://devfeed.tech/tags/stage.md>), [terminal](<https://devfeed.tech/tags/terminal.md>), [terminal-tools](<https://devfeed.tech/tags/terminal-tools.md>), [tool](<https://devfeed.tech/tags/tool.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

Ziggity is a lightweight terminal Git client that keeps its interface responsive while Git runs slower tasks in the background. It uses the system Git installation and ships as a small static binary; the article reports faster startup and lower memory use than lazygit in the project's Mac benchmarks, while noting results vary by machine and workload. Features include line-level staging, word-level diff highlighting, commit history and divergence views, and checkout suggestions that create tracking branches for remote refs. It supports mouse use and clipboard selection, including over SSH via OSC 52, and handles HTTPS credentials and multi-step operations in-app. Commit messages get configurable 50/72 character guidance and hook support; optional AI generation runs through a configurable external command. The article says whether it can replace established clients depends on individual workflows and required features.

### Source excerpt

Ziggity gives you complete Git workflow in one responsive terminal window, Stage lines, commit, branch, rebase, inspect history, and review live diffs without waiting on slow operations.

## Long tasks

DevFeed: [Long tasks](<https://devfeed.tech/articles/long-tasks-129398.md>)

Original publisher: [Read original article](<https://specification.website/spec/performance/long-tasks/>)

Author: Joost de Valk

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

Content type: tutorial

Language: en

Sources: [The Website Specification](<https://devfeed.tech/sources/the-website-specification.md>)

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [performance-optimization](<https://devfeed.tech/topics/performance-optimization.md>), [Interaction to Next Paint](<https://devfeed.tech/topics/interaction-to-next-paint.md>), [async](<https://devfeed.tech/topics/async.md>), [yield](<https://devfeed.tech/topics/yield.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [attribution](<https://devfeed.tech/tags/attribution.md>), [browser](<https://devfeed.tech/tags/browser.md>), [chrome](<https://devfeed.tech/tags/chrome.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [devtools](<https://devfeed.tech/tags/devtools.md>), [edge](<https://devfeed.tech/tags/edge.md>), [fallback](<https://devfeed.tech/tags/fallback.md>), [field](<https://devfeed.tech/tags/field.md>), [firefox](<https://devfeed.tech/tags/firefox.md>), [inp](<https://devfeed.tech/tags/inp.md>), [input](<https://devfeed.tech/tags/input.md>), [interaction-to-next-paint](<https://devfeed.tech/tags/interaction-to-next-paint.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [lab](<https://devfeed.tech/tags/lab.md>), [main-thread](<https://devfeed.tech/tags/main-thread.md>), [performance](<https://devfeed.tech/tags/performance.md>), [recommended](<https://devfeed.tech/tags/recommended.md>), [scheduler](<https://devfeed.tech/tags/scheduler.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [worker](<https://devfeed.tech/tags/worker.md>), [yield](<https://devfeed.tech/tags/yield.md>)

### AI overview

A long task occupies the browser's main thread for more than 50 ms, delaying input and rendering; responsiveness depends on how work is scheduled, not just how much JavaScript runs. Keep synchronous work under that threshold, slice 50-250 ms jobs and yield between slices, and move heavier computation to a Web Worker. The text recommends feature-detecting `scheduler.yield()`, which resumes ahead of lower-priority queued work, with a `setTimeout` or message-channel fallback where unsupported; avoid yielding on every iteration because yields have overhead. `scheduler.postTask()` can prioritize input-critical work. Defer noncritical scripts and keep event handlers light. In real-user monitoring, use Long Animation Frames attribution to rank script sources by blocking contribution; lab traces alone may miss field offenders. Verify on throttled devices and audit third-party scripts as well.

### Source excerpt

Keep main-thread tasks under the 50 ms long-task threshold: break up long work, yield with scheduler.yield(), offload heavy computation to a worker, and attribute what remains with Long Animation Frames in the field.

## Native Asyncio Comes to the Snowflake Python Connector

DevFeed: [Native Asyncio Comes to the Snowflake Python Connector](<https://devfeed.tech/articles/native-asyncio-comes-to-the-snowflake-python-connector-127038.md>)

Original publisher: [Read original article](<https://medium.com/snowflake/native-asyncio-comes-to-the-snowflake-python-connector-5941385ac80e?source=rss----34b6daafc07---4>)

Author: Patryk Czajka

Published: 2026-11-10T17:24:52Z

Content type: release

Language: en

Sources: [Snowflake Builders](<https://devfeed.tech/sources/snowflake-builders.md>)

Topics: [async](<https://devfeed.tech/topics/async.md>), [await](<https://devfeed.tech/topics/await.md>), [Python](<https://devfeed.tech/topics/python.md>), [FastAPI](<https://devfeed.tech/topics/fastapi.md>)

Tags: [2017](<https://devfeed.tech/tags/2017.md>), [3](<https://devfeed.tech/tags/3.md>), [addition](<https://devfeed.tech/tags/addition.md>), [aio](<https://devfeed.tech/tags/aio.md>), [api](<https://devfeed.tech/tags/api.md>), [applications](<https://devfeed.tech/tags/applications.md>), [arrow](<https://devfeed.tech/tags/arrow.md>), [async](<https://devfeed.tech/tags/async.md>), [asyncio](<https://devfeed.tech/tags/asyncio.md>), [await](<https://devfeed.tech/tags/await.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [connect](<https://devfeed.tech/tags/connect.md>), [core](<https://devfeed.tech/tags/core.md>), [dashboard](<https://devfeed.tech/tags/dashboard.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [data-quality](<https://devfeed.tech/tags/data-quality.md>), [event](<https://devfeed.tech/tags/event.md>), [event-loop](<https://devfeed.tech/tags/event-loop.md>), [fan](<https://devfeed.tech/tags/fan.md>), [python](<https://devfeed.tech/tags/python.md>), [rust](<https://devfeed.tech/tags/rust.md>), [snowflake](<https://devfeed.tech/tags/snowflake.md>)

### AI overview

Snowflake Connector for Python 5.0.0 adds `snowflake.connector.aio`, an awaitable API for Python 3.11+ built on the same Rust Universal Core as the existing synchronous connector. Async applications can await connection, query, fetch, transaction, Arrow, and pandas operations, keeping the event loop free while Snowflake work waits on the network; independent queries can run concurrently on separate cursors, though warehouse capacity and queuing still affect total time. The synchronous API remains available for scripts and ordinary functions, and both APIs share the implementation. Version 5.0.0 also adds pandas results for JSON responses; Core Arrow conversion is opt-in and in public preview. The excerpt recommends checking the upgrade guide and comparing results, types, and errors when moving from 4.x.

### Source excerpt

Version 5.0.0 is the same package you already install, now with an awaitable API built on Universal Core. If your Python service runs on an event loop, calling Snowflake has meant handing the call to a thread pool so it doesn't block everything else. In our public preview post we introduced Universal Core; this is the Python feature it made room for. Snowflake Connector for Python 5.0.0 became generally available on October 15. It is still snowflake-connector-python, with the same synchronous API. Check the upgrade guide for behavior changes before switching. The package is a thin Python wrapper around Universal Core, the Rust core shared with the ODBC driver. The big addition is snowflake.connector.aio: native asyncio support, the feature you've asked us for most, going back to a 2017 GitHub issue. TL;DR If you run async Python against Snowflake, install snowflake-connector-python 5.0.0 on Python 3.11 or later. Async applications import snowflake.connector.aio and await the calls that talk to Snowflake: connect, execute, fetch, transactions, Arrow, and pandas. One event loop can now hold many Snowflake queries in flight next to the rest of your I/O, with no thread pool around the connector. Asyncio benefits Most of what an application does with Snowflake is wait. It sends SQL, the warehouse runs it, and the result comes back over HTTPS. Asyncio is built for that: while one coroutine waits on the network, the event loop runs the others. With a native async connector, your application can await Snowflake calls directly, without moving them onto a worker thread. Web services and APIs. Applications built with FastAPI and other async frameworks can now query Snowflake without blocking the server while they wait for results. Snowflake SQLAlchemy supports SQLAlchemy's asyncio extension on this connector, so an AsyncSession can run those queries directly. Fan-out queries. A dashboard tile, a data-quality check, or a metadata crawl often runs a few dozen small, independent

## FRESCO: A Novel Consistency Control for Asynchronous Pipeline Parallel Training

DevFeed: [FRESCO: A Novel Consistency Control for Asynchronous Pipeline Parallel Training](<https://devfeed.tech/articles/fresco-a-novel-consistency-control-for-asynchronous-pipeline-parallel-training-125345.md>)

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

Author: Dongyeop Lee, Namhoon Lee

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

Content type: article

Language: en

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

Topics: [distributed-training](<https://devfeed.tech/topics/distributed-training.md>), [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [activation](<https://devfeed.tech/tags/activation.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [gradient](<https://devfeed.tech/tags/gradient.md>), [large](<https://devfeed.tech/tags/large.md>), [llm](<https://devfeed.tech/tags/llm.md>), [memory](<https://devfeed.tech/tags/memory.md>), [model](<https://devfeed.tech/tags/model.md>), [model-development](<https://devfeed.tech/tags/model-development.md>), [model-training](<https://devfeed.tech/tags/model-training.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [pipeline-parallelism](<https://devfeed.tech/tags/pipeline-parallelism.md>), [resource](<https://devfeed.tech/tags/resource.md>), [systems](<https://devfeed.tech/tags/systems.md>), [training](<https://devfeed.tech/tags/training.md>)

### AI overview

FRESCO addresses instability in asynchronous pipeline-parallel training by treating gradient inconsistency as a mismatch between error signals and forward-time features. It constrains updates to make the smallest modification that acts trivially on the activation subspace, allowing parameter changes that preserve forward-equivalence. In reported LLM pre-training results, at pipeline depth 32 it matched the strongest asynchronous baseline's loss with 43% fewer iterations and 30% less wall-clock time. The abstract reports lower memory overhead, but its figure is malformed ("8~921x"), so the amount cannot be stated reliably. These are abstract-level results; no implementation or experimental details are supplied.

### Source excerpt

arXiv:2611.11238v1 Announce Type: new Abstract: Asynchronous pipeline parallelism can accelerate distributed model training, but suffers from instability caused by inconsistent gradient computations. We identify a fundamental source of this inconsistency: error signals are coupled to forward-time features, not just parameter states. This means that parameters may evolve as long as they preserve forward-equivalence. Leveraging this insight, we introduce FRESCO, which frames asynchronous updates as a constrained optimization problem: it finds the minimal update modification that acts trivially on the activation subspace. We demonstrate that FRESCO consistently outperforms representative asynchronous baselines in LLM pre-training, with the gains most pronounced under deep pipelines and high inconsistency levels: at pipeline depth 32, it reaches the same loss as the strongest baseline with 43% fewer iterations and 30% less wall-clock time, while requiring 8~921$\times$ less memory overhead. Moving beyond the current limitations, FRESCO establishes a new foundation for high-utilization pipeline parallel training, providing a scalable path for large-model development on diverse, resource-constrained systems.

## Seamless Reconfiguration for DAG-BFT (Technical Report)

DevFeed: [Seamless Reconfiguration for DAG-BFT (Technical Report)](<https://devfeed.tech/articles/seamless-reconfiguration-for-dag-bft-technical-report-126695.md>)

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

Author: Michael Yiqing Hu, Leander Jehl, Paul Franke-Bergmann, Jialin Li, Christian Berger

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

Content type: article

Language: en

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

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [byzantine-fault-tolerance](<https://devfeed.tech/tags/byzantine-fault-tolerance.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dag](<https://devfeed.tech/tags/dag.md>), [downtime](<https://devfeed.tech/tags/downtime.md>), [latency](<https://devfeed.tech/tags/latency.md>), [network](<https://devfeed.tech/tags/network.md>), [nodes](<https://devfeed.tech/tags/nodes.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [report](<https://devfeed.tech/tags/report.md>)

### AI overview

The report presents a protocol for reconfiguring membership in asynchronous DAG-based Byzantine atomic broadcast without halting DAG growth. Existing approaches described in the abstract either pause operation or wait for a predetermined epoch boundary; a single agreed switching round is difficult because dissemination may already have advanced before processes learn of it. The proposed protocol allows membership and corresponding quorum thresholds to change while the DAG continues growing. The authors claim it is the first seamless reconfiguration protocol for this setting in a fully asynchronous network.

### Source excerpt

arXiv:2610.00896v2 Announce Type: replace Abstract: Byzantine Atomic Broadcast in Asynchronous networks has been studied extensively for decades. In a fully asynchronous system with even one possible crash failure, the FLP impossibility result rules out deterministic consensus, motivating randomized protocols that achieve termination with probability one. More recently, DAG-Rider popularized a new abstraction in which processes continuously reliably broadcast blocks to construct a Directed Acyclic Graph (DAG) and then locally derive a total order using a randomized perfect coin. This separation of dissemination from ordering has renewed interest in asynchronous DAG-based Byzantine Fault Tolerance (BFT) and inspired numerous protocols that improve expected latency or throughput. Reconfiguration, however, remains largely unexplored. Existing DAG-based BFT protocols generally assume a static set of processes, whereas deployed systems must occasionally add or remove nodes in response to operational demands. Existing solutions are not seamless; they either pause the system or delay membership changes until a predetermined epoch boundary. This may be impractical and can introduce downtime. A single agreed switching round is difficult to use seamlessly: by the time processes learn it, the dissemination layer may already have advanced beyond it. In this work, we present a seamless reconfiguration protocol for Asynchronous DAG-based Byzantine Atomic Broadcast. Our protocol allows the DAG to continue growing while the membership and corresponding quorum thresholds change, without halting the system. To the best of our knowledge, ours is the first protocol to provide seamless reconfiguration for DAG-based Byzantine atomic broadcast in a fully asynchronous network.

## Adaptive Scheduling Pipeline for Multi-Instance Asynchronous Reinforcement Learning

DevFeed: [Adaptive Scheduling Pipeline for Multi-Instance Asynchronous Reinforcement Learning](<https://devfeed.tech/articles/adaptive-scheduling-pipeline-for-multi-instance-asynchronous-reinforcement-learning-123317.md>)

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

Author: Salah Chikhi, Luis Zuin, Entong Li, Zeng Li

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

Content type: article

Language: en

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

Topics: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Reinforcement learning](<https://devfeed.tech/topics/reinforcement-learning.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [async](<https://devfeed.tech/topics/async.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [asynchronous-architecture](<https://devfeed.tech/tags/asynchronous-architecture.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [dispatch](<https://devfeed.tech/tags/dispatch.md>), [domain](<https://devfeed.tech/tags/domain.md>), [generation](<https://devfeed.tech/tags/generation.md>), [inference](<https://devfeed.tech/tags/inference.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [knowledge](<https://devfeed.tech/tags/knowledge.md>), [lag](<https://devfeed.tech/tags/lag.md>), [language](<https://devfeed.tech/tags/language.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [learning](<https://devfeed.tech/tags/learning.md>), [llms](<https://devfeed.tech/tags/llms.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [reinforcement-learning](<https://devfeed.tech/tags/reinforcement-learning.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>)

### AI overview

ASP is an offline preprocessing scheduler designed to improve rollout utilization in multi-instance asynchronous LLM reinforcement learning. In one pass, it addresses padding bubbles caused by variable lengths within minibatches, skewness bubbles from long-tail outputs, and sorting bubbles that disrupt training-queue occupancy. The scheduler is integrated into an architecture that separates rollout from training while making policy lag observable and bounded. The abstract reports up to 3.22x end-to-end throughput improvement and up to 76.8% lower iteration time versus MindSpeed-RL, and up to 62.5% lower iteration time versus verl; scheduling alone reduces mean iteration time by 10.9%. It reports more robust scaling with added generation resources and no visible convergence degradation in the measured bounded-lag regime. An internal telecom-domain workflow reportedly cut training time from over three months to about two months. These are abstract-level claims; no experimental setup or detailed measurements are supplied here.

### Source excerpt

arXiv:2611.08864v1 Announce Type: cross Abstract: We present the Adaptive Scheduling Pipeline (ASP), an offline rollout scheduler for multi-instance asynchronous reinforcement learning (RL) of large language models (LLMs). ASP jointly reduces three sources of rollout underutilization - padding bubbles from intra-minibatch length heterogeneity, skewness bubbles from long-tail outputs, and sorting bubbles from fluctuations in training-queue occupancy induced by length-sorted dispatch - through a single offline preprocessing pass. This enables efficient multi-instance rollout that overcomes the early scaling plateau of single-instance inference while smoothing the arrival of generated samples at the trainer. We integrate the scheduler into an asynchronous architecture that decouples rollout from training while keeping policy lag observable and bounded. Complete ASP improves end-to-end throughput by up to 3.22 times and reduces iteration time by up to 76.8% relative to MindSpeed-RL, while reducing iteration time by up to 62.5% relative to verl. Within ASP, scheduling reduces mean iteration time by 10.9%. ASP also scales more robustly with additional generation resources than these baselines and shows no visible convergence degradation in the measured bounded-lag regime. ASP has since been used in an internal telecom-domain RL post-training workflow, reducing the reported training period from more than three months to about two months and producing a domain-enhanced model for knowledge answering and tool calling.

## TPIC: Energy-Conserving Space Plasma Simulations on GPU Supercomputers

DevFeed: [TPIC: Energy-Conserving Space Plasma Simulations on GPU Supercomputers](<https://devfeed.tech/articles/tpic-energy-conserving-space-plasma-simulations-on-gpu-supercomputers-123697.md>)

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

Author: Luca Pennati, Ivy Peng, Stefano Markidis

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

Content type: article

Language: en

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

Topics: [GPU](<https://devfeed.tech/topics/gpu.md>), [Multi-GPU](<https://devfeed.tech/topics/multi-gpu.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [acceleration](<https://devfeed.tech/tags/acceleration.md>), [all](<https://devfeed.tech/tags/all.md>), [amd](<https://devfeed.tech/tags/amd.md>), [applications](<https://devfeed.tech/tags/applications.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [asynchronous-communication](<https://devfeed.tech/tags/asynchronous-communication.md>), [balance](<https://devfeed.tech/tags/balance.md>), [cases](<https://devfeed.tech/tags/cases.md>), [communication](<https://devfeed.tech/tags/communication.md>), [complete](<https://devfeed.tech/tags/complete.md>), [cs-ce](<https://devfeed.tech/tags/cs-ce.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [domains](<https://devfeed.tech/tags/domains.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [energy](<https://devfeed.tech/tags/energy.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [plasma](<https://devfeed.tech/tags/plasma.md>), [simulations](<https://devfeed.tech/tags/simulations.md>), [space](<https://devfeed.tech/tags/space.md>), [supercomputers](<https://devfeed.tech/tags/supercomputers.md>)

### AI overview

TPIC is a GPU implementation of the Energy Conserving Semi-Implicit Method (ECSIM) for particle-in-cell space plasma simulations. It extends exact discrete energy conservation to closed domains with conducting boundaries by deriving and canceling a spurious term in the discrete Poynting flux theorem. The complete particle and field cycle runs on NVIDIA and AMD GPUs, using matrix-engine acceleration and asynchronous communication and computation. Across electrostatic and electrodynamic tests, including magnetic reconnection with conducting walls, the authors report agreement with analytical theory or reference results and total energy conservation to machine precision. At 4,096 AMD GPUs, TPIC advanced 1.9 trillion particles with 96.8% weak scaling efficiency.

### Source excerpt

arXiv:2611.09624v1 Announce Type: cross Abstract: Artificial heating and numerical damping affect particle energization in kinetic space plasma simulations, even when the numerical scheme remains stable. Implicit and semi implicit energy conserving Particle-in-Cell (PIC) methods eliminate these errors in the discrete energy balance while relaxing explicit stability constraints. We present TPIC, a massively parallel implementation of the Energy Conserving Semi-Implicit Method (ECSIM) for GPU supercomputers. We extend the exact energy conservation in the ECSIM formulation to closed domains with conducting boundaries by deriving and canceling a spurious term in the discrete Poynting flux theorem. TPIC executes the complete particle and field cycle on NVIDIA and AMD GPUs, combining matrix-engine acceleration with asynchronous communication and computation. We validate TPIC in a variety of electrostatic and electrodynamic test cases relevant for space plasma physics applications, including quasineutral plasma expansion, two-stream instability, Whistler waves, Weibel instability, Whistler turbulence, and three-dimensional magnetic reconnection with conducting walls and 12.3 billion particles. We show that in all scenarios, TPIC agrees with the corresponding analytical theory or reference numerical results, and preserves the total system energy to machine precision. On 4,096 AMD GPUs, TPIC advances 1.9 trillion particles with 96.8\% weak scaling efficiency.

## Background Jobs in .NET: Hangfire vs Quartz vs Wolverine vs BackgroundService

DevFeed: [Background Jobs in .NET: Hangfire vs Quartz vs Wolverine vs BackgroundService](<https://devfeed.tech/articles/background-jobs-in-net-hangfire-vs-quartz-vs-wolverine-vs-backgroundservice-121427.md>)

Original publisher: [Read original article](<https://blog.devops.dev/background-jobs-in-net-hangfire-vs-quartz-vs-wolverine-vs-backgroundservice-ec87d15732c3?source=rss----33f8b2d9a328---4>)

Author: Bharat Chandera

Published: 2026-11-06T09:45:59Z

Content type: comparison

Language: en

Sources: [DevOps.dev](<https://devfeed.tech/sources/devops-dev.md>)

Topics: [.NET](<https://devfeed.tech/topics/net.md>), [Job](<https://devfeed.tech/topics/job.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [background-jobs](<https://devfeed.tech/tags/background-jobs.md>), [dotnet](<https://devfeed.tech/tags/dotnet.md>), [hangfire](<https://devfeed.tech/tags/hangfire.md>), [net](<https://devfeed.tech/tags/net.md>), [quartz](<https://devfeed.tech/tags/quartz.md>), [services](<https://devfeed.tech/tags/services.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [wolverine](<https://devfeed.tech/tags/wolverine.md>)

### AI overview

The excerpt distinguishes two background-work needs: a loop that runs for the lifetime of the app (such as polling a queue or pushing metrics) and work started by a request that must survive a process restart. It names BackgroundService, Hangfire, Quartz.NET, and Wolverine as tools that overlap but address different background-job problems. The excerpt ends before explaining their differences or offering selection guidance.

### Source excerpt

Four tools, four different ideas of what a "background job" is. Here is how to pick without regretting it in six months. Continue reading on DevOps.dev "

## Zero Mismatch, Simple Async RL: REINFORCE Zero, DeepSeek-V4.1 and Kimi K3.1

DevFeed: [Zero Mismatch, Simple Async RL: REINFORCE Zero, DeepSeek-V4.1 and Kimi K3.1](<https://devfeed.tech/articles/zero-mismatch-simple-async-rl-reinforce-zero-deepseek-v4-1-and-kimi-k3-1-122091.md>)

Original publisher: [Read original article](<https://vllm.ai/blog/2026-11-06-zero-mismatch-async-rl>)

Author: Ao Shen (Inferact), Jian Hu (NVIDIA Research), Yan Bai (NVIDIA DevTech), Shekhar Pandey (AMD), and the REINFORCE Zero authors

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

Content type: article

Language: en

Sources: [vLLM Blog](<https://devfeed.tech/sources/vllm-blog.md>)

Topics: [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [async](<https://devfeed.tech/topics/async.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [quantization](<https://devfeed.tech/topics/quantization.md>), [grpo](<https://devfeed.tech/topics/grpo.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [7-4](<https://devfeed.tech/tags/7-4.md>), [8k](<https://devfeed.tech/tags/8k.md>), [about](<https://devfeed.tech/tags/about.md>), [ai-engineering](<https://devfeed.tech/tags/ai-engineering.md>), [align](<https://devfeed.tech/tags/align.md>), [amd](<https://devfeed.tech/tags/amd.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [deepseek](<https://devfeed.tech/tags/deepseek.md>), [deepseek-v4-1-flash](<https://devfeed.tech/tags/deepseek-v4-1-flash.md>), [flash](<https://devfeed.tech/tags/flash.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [kimi](<https://devfeed.tech/tags/kimi.md>), [lag](<https://devfeed.tech/tags/lag.md>), [llm-inference](<https://devfeed.tech/tags/llm-inference.md>), [model-serving](<https://devfeed.tech/tags/model-serving.md>), [open-source-ai](<https://devfeed.tech/tags/open-source-ai.md>), [reinforcement-learning](<https://devfeed.tech/tags/reinforcement-learning.md>), [rl](<https://devfeed.tech/tags/rl.md>), [sampling](<https://devfeed.tech/tags/sampling.md>), [training](<https://devfeed.tech/tags/training.md>), [trains](<https://devfeed.tech/tags/trains.md>), [v4-1-flash](<https://devfeed.tech/tags/v4-1-flash.md>), [vllm-blog](<https://devfeed.tech/tags/vllm-blog.md>), [zero](<https://devfeed.tech/tags/zero.md>)

### AI overview

REINFORCE Zero argues that asynchronous RL can train stably on stale samples when rollout and learner kernels are aligned, leaving unclipped token level importance sampling to correct weight lag. The paper reports stable training through 20,000 updates and learning at policy lag 64; in one comparison, importance weight deviation peaked at 1.50 times its median with aligned kernels versus 442.54 times with standard kernels. Without alignment, training drifted and a sequence gate rejected 24.48% of sequences. Alignment has a speed cost: one OSWorld setup took 6.8% longer per step than standard kernel IS with a gate. The excerpt also reports zero-mismatch deployments for DeepSeek-V4.1-Flash and Kimi K3.1, including AMD MI355X runs, while noting ongoing performance work and that long asynchronous runs on the flagship models remain future work.

### Source excerpt

Asynchronous RL trains on stale weights. Align rollout and training kernels bit for bit, and unclipped importance sampling corrects that lag. Plus zero-mismatch RL for DeepSeek-V4.1-Flash, Kimi K3.1 and AMD MI355X.

## Agents Are Going Async

DevFeed: [Agents Are Going Async](<https://devfeed.tech/articles/agents-are-going-async-119838.md>)

Original publisher: [Read original article](<https://www.langchain.com/blog/agents-are-going-async>)

Author: LangChain Accounts

Published: 2026-11-05T20:03:27Z

Content type: tutorial

Language: en

Sources: [LangChain Blog](<https://devfeed.tech/sources/langchain-blog.md>)

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>), [async](<https://devfeed.tech/topics/async.md>), [supervisor agent pattern](<https://devfeed.tech/topics/supervisor-agent-pattern.md>), [hierarchical agent systems](<https://devfeed.tech/topics/hierarchical-agent-systems.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [DeepSeek Harness](<https://devfeed.tech/topics/dsh.md>), [Langgraph](<https://devfeed.tech/topics/langgraph.md>)

Tags: [added](<https://devfeed.tech/tags/added.md>), [addition](<https://devfeed.tech/tags/addition.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-infrastructure](<https://devfeed.tech/tags/agent-infrastructure.md>), [agents](<https://devfeed.tech/tags/agents.md>), [also](<https://devfeed.tech/tags/also.md>), [api](<https://devfeed.tech/tags/api.md>), [application](<https://devfeed.tech/tags/application.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [async](<https://devfeed.tech/tags/async.md>), [background](<https://devfeed.tech/tags/background.md>), [deep](<https://devfeed.tech/tags/deep.md>), [let](<https://devfeed.tech/tags/let.md>), [notifications](<https://devfeed.tech/tags/notifications.md>), [responsive](<https://devfeed.tech/tags/responsive.md>), [run](<https://devfeed.tech/tags/run.md>), [subagents](<https://devfeed.tech/tags/subagents.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [work](<https://devfeed.tech/tags/work.md>), [workers](<https://devfeed.tech/tags/workers.md>)

### AI overview

Async subagents let an orchestrator stay available while long-running work proceeds in the background. In Deep Agents, `start_async_task` returns immediately; the orchestrator can check, update, cancel, or list tasks, and workers report results when they finish. Follow-ups either interrupt and restart a task (the default) or enqueue instructions for after it finishes. Notifications behave differently depending on whether the orchestrator is busy, idle, or awaiting approval; approval requests remain on the subagent's thread, and Managed Deep Agents on Slack posts them to the original thread. Async subagents are available in Deep Agents for Python and JavaScript and Managed Deep Agents. Task notifications are in beta, so the API may change.

### Source excerpt

Async subagents let an agent stay responsive while background workers run long tasks. How the orchestrator, notifications and approvals work in Deep Agents.

## D3D: Decoupled Diffusion Drafting for Asynchronous Speculative Decoding

DevFeed: [D3D: Decoupled Diffusion Drafting for Asynchronous Speculative Decoding](<https://devfeed.tech/articles/d3d-decoupled-diffusion-drafting-for-asynchronous-speculative-decoding-118466.md>)

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

Author: Baoyou Chen, Ruiqiao Mei, Guancong Lin, Tao Song, Weihao Yuan, Qun Liu, Siyu Zhu

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

Content type: article

Language: en

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

Topics: [Model Optimizer](<https://devfeed.tech/topics/model-optimizer.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [acceptance](<https://devfeed.tech/tags/acceptance.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [autoregressive](<https://devfeed.tech/tags/autoregressive.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [block](<https://devfeed.tech/tags/block.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [candidate](<https://devfeed.tech/tags/candidate.md>), [code](<https://devfeed.tech/tags/code.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [decoding](<https://devfeed.tech/tags/decoding.md>), [denoising](<https://devfeed.tech/tags/denoising.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [dflash](<https://devfeed.tech/tags/dflash.md>), [diffusion](<https://devfeed.tech/tags/diffusion.md>), [draft](<https://devfeed.tech/tags/draft.md>), [effect](<https://devfeed.tech/tags/effect.md>), [hidden](<https://devfeed.tech/tags/hidden.md>), [hidden-states](<https://devfeed.tech/tags/hidden-states.md>), [layers](<https://devfeed.tech/tags/layers.md>), [speculative-decoding](<https://devfeed.tech/tags/speculative-decoding.md>)

### AI overview

D3D enables asynchronous speculative decoding by using a standalone diffusion drafter that does not need updated target-model hidden states between blocks. It combines blockwise denoising with auxiliary autoregressive supervision, allowing it to draft successor blocks in one packed pass while the target verifies earlier candidates. To lower packed-drafting cost, the authors prune layers based on their effect on acceptance length; removing five of 36 layers retained over 99% of mean acceptance length across three benchmarks with Qwen3-8B. Across seven benchmarks, reported average speedups were 5.00x with Qwen3-8B and 5.71x with Qwen3-32B, versus 4.03x and 3.67x for DFlash, respectively. On GSM8K with Qwen3-32B, D3D reached 7.48x. These are abstract-reported results.

### Source excerpt

arXiv:2611.06425v1 Announce Type: new Abstract: Target-conditioned diffusion drafters predict candidate tokens in parallel, yet each new block must wait for updated target-model hidden states. This forces drafting and verification to run sequentially, limiting speedup even though each block is generated in one pass. We introduce D3D, a standalone diffusion drafter that removes this inter-round dependency. D3D combines blockwise denoising with auxiliary autoregressive supervision to achieve long accepted prefixes without target hidden states. This independence lets D3D draft successor blocks during verification in one packed pass, enabling asynchronous speculative decoding. We progressively prune layers according to their effect on acceptance length to reduce the cost of packed drafting. Removing five of 36 layers retains over 99\% of mean acceptance length across three benchmarks with Qwen3-8B as the target. Across seven benchmarks, D3D averages 5.00$\times$ and 5.71$\times$ decoding speedup with Qwen3-8B and Qwen3-32B targets, compared with 4.03$\times$ and 3.67$\times$ for DFlash. On GSM8K with Qwen3-32B, speedup reaches 7.48$\times$. Code is publicly available at https://github.com/fudan-generative-vision/D3D.

## Asynchronous Robot Policies

DevFeed: [Asynchronous Robot Policies](<https://devfeed.tech/articles/asynchronous-robot-policies-117570.md>)

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

Author: Sombit Dey, Luc Van Gool, Danda Pani Paudel

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

Content type: article

Language: en

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

Topics: [Robot Manipulation](<https://devfeed.tech/topics/robot-manipulation.md>), [Robotics](<https://devfeed.tech/topics/robotics.md>), [Physical AI](<https://devfeed.tech/topics/physical-ai.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [async](<https://devfeed.tech/topics/async.md>), [vlm](<https://devfeed.tech/topics/vlm.md>)

Tags: [arp](<https://devfeed.tech/tags/arp.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ro](<https://devfeed.tech/tags/cs-ro.md>), [delay](<https://devfeed.tech/tags/delay.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [environments](<https://devfeed.tech/tags/environments.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fast](<https://devfeed.tech/tags/fast.md>), [foundation](<https://devfeed.tech/tags/foundation.md>), [foundation-models](<https://devfeed.tech/tags/foundation-models.md>), [framework](<https://devfeed.tech/tags/framework.md>), [generalist](<https://devfeed.tech/tags/generalist.md>), [independent](<https://devfeed.tech/tags/independent.md>), [language-model](<https://devfeed.tech/tags/language-model.md>), [latency](<https://devfeed.tech/tags/latency.md>), [lightweight](<https://devfeed.tech/tags/lightweight.md>), [low-level](<https://devfeed.tech/tags/low-level.md>), [policies](<https://devfeed.tech/tags/policies.md>), [robot](<https://devfeed.tech/tags/robot.md>)

### AI overview

Asynchronous Robot Policy (ARP) separates slow semantic reasoning from fast robot control: a high-capacity vision-language model updates semantic memory asynchronously, while a lightweight Vision-Action Expert uses it to generate actions at a higher frequency. To handle stale memory and delayed execution, the expert is trained with temporally mismatched observations. On Franka manipulation tasks, the abstract reports an 18% higher success rate and 20% less execution time in quasi-static setups, and 3-5 times baseline performance in dynamic simulations. It also reports that the VLM can run at one-tenth its nominal frequency without significant performance loss. These are abstract-reported results; the supplied excerpt does not provide further experimental details.

### Source excerpt

arXiv:2611.05155v1 Announce Type: cross Abstract: Scaling vision-language foundation models has significantly advanced generalist robot manipulation, but the increased model scale introduces computational latency that degrades real-time physical reactivity. Existing Vision-Language-Action (VLA) architectures execute high-level semantic reasoning and action ex- ecution sequentially within the primary control loop, creating a fundamental tension between semantic-reasoning capability and robot agility. To address this, we propose Asynchronous Robot Policy (ARP), an architectural framework that decouples semantic reasoning from low-level action generation using asynchronous processes operating at independent frequencies. In ARP, a high-capacity Vision-Language Model (VLM) asynchronously updates a semantic memory at low fre- quency, while a lightweight Vision-Action Expert, conditioned on this semantic memory, generates robot actions at a much higher control frequency. Such a formulation, enables having a fast perception-action loop without compromising on the semantic capability. To overcome asynchronous memory staleness, ARP trains the vision-action expert on the semantic staleness and execution delay, with temporally mismatched observation across processes. On Franka manipulation tasks, ARP achieves an 18% higher success rate and 20% less time need for execution in quasi-static setups, while 3-5 times baseline performance in dynamic simulation environments. Furthermore, ARP enables operating the VLM at 10 times lower than its nominal frequency with no significant performance loss making it much more efficient than the baseline. These results highlight the architectural advantages of modeling robot policies as asynchronous processes, enabling real-world reactive deployment without sacrificing the scale of foundation models.

## The Agent Board: Kanban for Machines; Durable Coordination for Agents That Outlive the Conversation

DevFeed: [The Agent Board: Kanban for Machines; Durable Coordination for Agents That Outlive the Conversation](<https://devfeed.tech/articles/the-agent-board-kanban-for-machines-durable-coordination-for-agents-that-outlive-the-conversation-116481.md>)

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

Author: Tyler Hunt, Donald Nguyen, Gurbinder Gill

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

Content type: article

Language: en

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

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [agent to agent communication](<https://devfeed.tech/topics/agent-to-agent-communication.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [block](<https://devfeed.tech/tags/block.md>), [board](<https://devfeed.tech/tags/board.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [events](<https://devfeed.tech/tags/events.md>), [fields](<https://devfeed.tech/tags/fields.md>), [handler](<https://devfeed.tech/tags/handler.md>), [harness](<https://devfeed.tech/tags/harness.md>), [kanban](<https://devfeed.tech/tags/kanban.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [mirrors](<https://devfeed.tech/tags/mirrors.md>), [policy](<https://devfeed.tech/tags/policy.md>), [post](<https://devfeed.tech/tags/post.md>), [roles](<https://devfeed.tech/tags/roles.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [single-threaded](<https://devfeed.tech/tags/single-threaded.md>), [substrate](<https://devfeed.tech/tags/substrate.md>), [team](<https://devfeed.tech/tags/team.md>)

### AI overview

The Agent Board is a durable shared task table for coordinating agents across turns, agents, and external systems. Agents can post or watch tasks and block without holding a process; the Board Keeper brings in external events, matches them to waiting tasks by interpreting their prose, and can allocate agents by role. Loadable policy kernels assign meaning to statuses and roles, but the board itself does not enforce those conventions. In three small simulated pilots, board wait cost stayed flat as wait length increased, while naive polling grew about 165-fold; a plain external watcher was cheaper. The Board Keeper produced no false wakes but missed 3.6% of real wakes.

### Source excerpt

arXiv:2611.04100v1 Announce Type: cross Abstract: Harnesses for large language models have converged on a single-threaded shape: one agent, one history, one machine, one sitting. That shape fails work that spans many agents, outlives any one model call, or waits on systems that are not agents. We describe the Agent Board, the coordination substrate in the Corvic harness. The board is a durable, shared table of semi-semantic tasks: a few exact fields the system routes on, and a free-form body that only language models read. Agents post tasks, watch tasks, and block on them, ending their turn and holding no process until a matching post wakes them. A system agent, the Board Keeper, acts as the interrupt handler for the board: it carries events from non-agent parts of the harness onto the board, matches them to waiting tasks by reading their prose, and allocates new agents for tasks that name a kind of agent rather than an instance. Loadable coordination policy kernels give statuses and roles meaning for a given pattern of work, without the board enforcing them. The design mirrors the kanban board a human team puts on a wall. We argue it is what persistent agent products such as Meta Muse, OpenAI dots and SpaceXAI Grok Bot need once an agent must wait, hand off work, or work with agents from another vendor. We view the board as an operating-system scheduler for agents and state where the analogy breaks. We separate what the mechanism guarantees from what it leaves to convention, and report a trace from a live board and three small simulated pilots. In the pilots, the wait cost of the board was flat in wait length while naive polling grew about 165-fold, but a plain external watcher was cheaper than the board. The Board Keeper matched prose waiters with no false wakes but missed 3.6 percent of real wakes.

## When the Consumer Is an Agent: Execution-Grounded Service-Level Agreements

DevFeed: [When the Consumer Is an Agent: Execution-Grounded Service-Level Agreements](<https://devfeed.tech/articles/when-the-consumer-is-an-agent-execution-grounded-service-level-agreements-116484.md>)

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

Author: Michal Orzechowski, Renata G. Slota, Jacek Kitowski

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

Content type: article

Language: en

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

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [service](<https://devfeed.tech/topics/service.md>), [control-plane](<https://devfeed.tech/topics/control-plane.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [act](<https://devfeed.tech/tags/act.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [all](<https://devfeed.tech/tags/all.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [assessment](<https://devfeed.tech/tags/assessment.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [call](<https://devfeed.tech/tags/call.md>), [can](<https://devfeed.tech/tags/can.md>), [complete](<https://devfeed.tech/tags/complete.md>), [completion](<https://devfeed.tech/tags/completion.md>), [consumer](<https://devfeed.tech/tags/consumer.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [control](<https://devfeed.tech/tags/control.md>), [control-plane](<https://devfeed.tech/tags/control-plane.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [data](<https://devfeed.tech/tags/data.md>), [execution](<https://devfeed.tech/tags/execution.md>), [service](<https://devfeed.tech/tags/service.md>), [service-level-agreements](<https://devfeed.tech/tags/service-level-agreements.md>)

### AI overview

The paper proposes execution-grounded completion contracts for LLM agents using asynchronous services. An independent control plane checks whether a required service-state condition becomes observable by a deadline, decides whether to admit completion, and directs recovery. In a live multi-provider data service tested on placement and deletion with heterogeneous models and an injected transfer delay, existing policies sometimes accepted late tasks and rejected on-time ones. With enforcement, accepted completions stayed consistent with later observations; all included healthy tasks completed, while unresolved faulted tasks ended as unverified. The findings support governing completion through observed service state rather than the agent's self-assessment.

### Source excerpt

arXiv:2611.04182v1 Announce Type: new Abstract: Large language model (LLM) agents increasingly act as service consumers. They select operations and report whether a task is complete. In an asynchronous distributed service, an accepted call or immediate state read does not establish that the required state became observable by its deadline. We introduce execution-grounded completion contracts, which treat completion as a service-level outcome. An independent control plane observes a deadline-bound service-state predicate, admits completion, and directs recovery while the agent performs the task. We evaluate placement and deletion in a live multi-provider data service with heterogeneous models and an injected transfer delay. Across policies, some tasks that missed the deadline were accepted and some that met it were rejected. Under enforcement, accepted completions remained consistent with later observations; all included healthy tasks completed, and unresolved faulted tasks terminated as unverified. The results show that completion of these tasks can be governed by independent observation of service state rather than by the agent's self-assessment.

## Who Schedules Agent Memory? A Sidecar Approach to Long-Horizon Tasks

DevFeed: [Who Schedules Agent Memory? A Sidecar Approach to Long-Horizon Tasks](<https://devfeed.tech/articles/who-schedules-agent-memory-a-sidecar-approach-to-long-horizon-tasks-115089.md>)

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

Author: Qijia Zhuang (Nanjing University), Rui Liu (Northeastern University), Yuxiang Ren (Nanjing University)

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

Content type: article

Language: en

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

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [async](<https://devfeed.tech/topics/async.md>), [AI-driven information retrieval](<https://devfeed.tech/topics/ai-driven-information-retrieval.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-memory](<https://devfeed.tech/tags/agent-memory.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [hooks](<https://devfeed.tech/tags/hooks.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [latency](<https://devfeed.tech/tags/latency.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [memory](<https://devfeed.tech/tags/memory.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [queries](<https://devfeed.tech/tags/queries.md>), [retrieval](<https://devfeed.tech/tags/retrieval.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [sidecar](<https://devfeed.tech/tags/sidecar.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

MemSidecar separates memory scheduling from task execution to reduce the main agent's retrieval burden and waiting time in long-horizon tasks. Its Hooks mode delivers bound memory when execution events match predefined conditions. Foresight uses an independent agent to predict likely queries, retrieve results in parallel, and cache them for delivery when matching valid requests arrive. On MCP-Persona, the abstract reports scores of 41.23% for Hooks and 44.34% for Foresight, and says both reduce execution costs and latency; the excerpt provides no further evaluation details.

### Source excerpt

arXiv:2611.00779v1 Announce Type: new Abstract: As large language model agents increasingly undertake complex, long-horizon tasks, memory has become an important component for supporting sustained decision-making and action. Existing methods primarily focus on memory storage, updating, and retrieval, but often overlook how memory scheduling affects task execution: the main agent must identify memory needs, initiate retrieval, and wait for results while advancing the task, increasing both scheduling burden and execution time. To address this problem, we propose MemSidecar, which decouples memory scheduling from task execution through two independently selectable modes. Hooks directly delivers bound memory to the main agent when execution events match predefined conditions. Foresight uses an independent agent to predict potential queries, retrieve results in parallel, and store them in a cache, delivering matching and valid results when actual requests arrive. Hooks and Foresight achieve scores of 41.23% and 44.34% on MCP-Persona, respectively, while effectively reducing execution costs and latency and improving the efficiency of long-horizon agent execution.

## Li$^{2}$SAO: Lifting Light Singl-Rollout Asynchronous RL Optimization via Group-Relative Actor-Critic Bootstrapping

DevFeed: [Li$^{2}$SAO: Lifting Light Singl-Rollout Asynchronous RL Optimization via Group-Relative Actor-Critic Bootstrapping](<https://devfeed.tech/articles/li-2-sao-lifting-light-singl-rollout-asynchronous-rl-optimization-via-group-relative-actor-critic-bootstrapping-111493.md>)

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

Author: Zichen Bai, Yanli Wang, Yang Liu, Junhao Shi, Xueqin Liu, Jinguo Sun, Muye Li, Shaoqiang Zheng, Xuefei Diao, Zhuwei Zeng, Nan Duan, Peng Cao

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

Content type: article

Language: en

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

Topics: [grpo](<https://devfeed.tech/topics/grpo.md>), [post-training](<https://devfeed.tech/topics/post-training.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [async](<https://devfeed.tech/topics/async.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [bootstrapping](<https://devfeed.tech/tags/bootstrapping.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [grpo](<https://devfeed.tech/tags/grpo.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [lightweight](<https://devfeed.tech/tags/lightweight.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [performance](<https://devfeed.tech/tags/performance.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [reinforcement-learning](<https://devfeed.tech/tags/reinforcement-learning.md>), [sao](<https://devfeed.tech/tags/sao.md>), [training](<https://devfeed.tech/tags/training.md>)

### AI overview

Li²SAO addresses LiSAO's weak early training when its value model is still cold. It initially trains the actor with a group-relative advantage and the critic with a group-centered return, then switches to single-rollout generalized advantage estimation (GAE). The authors report that LiSAO, a lightweight reproduction of SAO without its pretrained value model, beats GRPO on multi-turn agentic tasks but trails it on single-turn reasoning and substantially lags early in training. In experiments, Li²SAO catches up with or surpasses GRPO early and raises the later performance ceiling. These findings are limited to the tasks and experiments described in the abstract.

### Source excerpt

arXiv:2610.40726v1 Announce Type: cross Abstract: Asynchronous reinforcement learning (RL) is becoming a mainstream paradigm for post-training large language models (LLMs), as it improves training efficiency by updating the model as rollouts arrive. Recent work argues that group-wise sampling in GRPO does not naturally fit asynchronous RL training because rollout lengths follow a long-tailed distribution, and proposes Single-rollout Asynchronous Optimization (SAO) to improve stability and off-policy behavior, especially on agentic tasks. However, SAO relies on a closed-source value model obtained from scaling value pretraining. In this paper, we analyze GRPO and LiSAO, our lightweight reproduction of SAO without the pretrained value model, on single-turn reasoning and multi-turn agentic tasks. We find that GRPO outperforms LiSAO on reasoning tasks, while the reverse holds on agentic tasks. Since the value model of LiSAO is not yet well trained , LiSAO lags behind GRPO substantially in early training steps. To address this issue, we propose Li$^{2}$SAO, which Lifts Light Single-rollout Asynchronous Optimization with group-relative actor-critic bootstrapping: while the critic is cold, a group-relative advantage trains the actor and a group-centered return trains the critic, after which training switches to single-rollout GAE. Experiments show that Li$^{2}$SAO catches up with or surpasses GRPO in early training and further raises the later performance ceiling. Code is available at https://github.com/jd-cc-coder/Li2SAO.

## Socket Programming in Python (Guide)

DevFeed: [Socket Programming in Python (Guide)](<https://devfeed.tech/articles/socket-programming-in-python-guide-110732.md>)

Original publisher: [Read original article](<https://realpython.com/python-sockets/>)

Author: Nathan Jennings

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

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [async](<https://devfeed.tech/topics/async.md>), [Exception handling](<https://devfeed.tech/topics/exception-handling.md>), [Learning](<https://devfeed.tech/topics/learning.md>)

Tags: [blocking](<https://devfeed.tech/tags/blocking.md>), [client](<https://devfeed.tech/tags/client.md>), [guide](<https://devfeed.tech/tags/guide.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [python](<https://devfeed.tech/tags/python.md>), [server](<https://devfeed.tech/tags/server.md>), [socket](<https://devfeed.tech/tags/socket.md>)

### AI overview

The tutorial builds Python TCP client and server examples, starting with a blocking echo server using `socket()`, `bind()`, `listen()`, `accept()`, and `sendall()`. It explains that TCP provides reliable, in-order delivery, while `recv()` may return fewer bytes than requested, so applications must track partial reads and writes. For multiple connections, it uses nonblocking sockets and `selectors` to monitor readiness and maintain per-connection buffers; this event-loop approach is synchronous and its suitability depends on workload. A later design adds a `Message` class and an application protocol: a two-byte length prefix, followed by a UTF-8 JSON header with content metadata, then the payload. The excerpt also covers catching socket-related `OSError`s, connection timeouts, and closing idle connections, while noting that TCP itself does not define message boundaries. The source is an excerpt and ends during the protocol implementation discussion.

### Source excerpt

Build a Python socket server and client from scratch, then extend it to handle multiple connections at once without blocking.

[Next page](<https://devfeed.tech/topics/async.md?cursor=WyIyMDI2LTEwLTMxVDE0OjAwOjAwKzAwOjAwIiwgImQ0ODBmMzdjLWU2YjEtNGE4ZS1iOTgyLThlNzI1YmNjYjg1NSJd>)