# DAG

Published articles for DAG.

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

## Inter-Layer Hessian Analysis of Neural Networks with DAG Architectures

DevFeed: [Inter-Layer Hessian Analysis of Neural Networks with DAG Architectures](<https://devfeed.tech/articles/inter-layer-hessian-analysis-of-neural-networks-with-dag-architectures-123116.md>)

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

Author: Maxim Bolshim (ITMO University, Saint Petersburg, Russia), Alexander Kugaevskikh (ITMO University, Saint Petersburg, Russia)

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

Content type: article

Language: en

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

Topics: [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [architectures](<https://devfeed.tech/tags/architectures.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [dag](<https://devfeed.tech/tags/dag.md>), [fully-connected](<https://devfeed.tech/tags/fully-connected.md>), [graph](<https://devfeed.tech/tags/graph.md>), [input](<https://devfeed.tech/tags/input.md>), [map](<https://devfeed.tech/tags/map.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [networks](<https://devfeed.tech/tags/networks.md>), [neural-networks](<https://devfeed.tech/tags/neural-networks.md>), [newton](<https://devfeed.tech/tags/newton.md>), [node](<https://devfeed.tech/tags/node.md>), [rank](<https://devfeed.tech/tags/rank.md>), [relu](<https://devfeed.tech/tags/relu.md>), [theoretical](<https://devfeed.tech/tags/theoretical.md>), [transport](<https://devfeed.tech/tags/transport.md>)

### AI overview

The paper organizes neural-network Hessians into blocks indexed by an architecture's DAG, separating Gauss-Newton curvature from residual tensor curvature. For the input Hessian, the tensor component vanishes on each smooth cell when every node map is locally affine in its parent activations; ReLU activations alone do not guarantee this, and the full parameter Hessian retains residual terms beyond the GGN. The authors define inter-layer resonance, geometric coupling, stable rank, and GN-Gap diagnostics, estimated stochastically with Hessian-vector products at a cost tied to graph evaluation and probe count. They report conditional bounds on curvature decay and residual-chain transport, and examples using MLPs and a roughly 11-million-parameter ResNet-18. The archival correction notes prior precedents for general DAG-Hessian calculus and withdraws the original broad novelty claims.

### Source excerpt

arXiv:2604.11639v2 Announce Type: replace Abstract: Automatic differentiation computes loss Hessians, while interpreting inter-layer interactions requires an explicit choice of graph-indexed blocks. This paper presents an analytical formalism that decomposes the full Hessian into blocks indexed by the DAG of an architecture. The standard decomposition $H = H^{GN} + H^T$ separates the Gauss-Newton component (positive semidefinite for a convex output loss) from the tensor component (residual curvature). If every node map is locally affine in its parent activations, the tensor component of the input Hessian vanishes on each smooth cell ($H^{T}_{v,w}=0$, $H^f_{v,w}=H^{GN}_{v,w}$); ReLU activations alone do not suffice. The full parametric Hessian contains residual terms that do not reduce to the GGN. Building on this decomposition, we use diagnostic metrics (inter-layer resonance $\mathcal{R}$, geometric coupling $\mathcal{C}$, stable rank $\mathcal{D}$, GN-Gap) with stochastic HVP-based estimates whose cost depends on graph evaluation and the number of probes. The theoretical analysis gives conditional bounds on curvature decay and residual-chain transport; empirical examples span fully connected MLPs (Exp. 1-5) and convolutional architectures (ResNet-18, ${\sim}11$M parameters, Exp. 6). When the architecture reduces to a single node, all definitions collapse to the standard Hessian $\nabla^2_\theta\mathcal{L}(\theta)\in\mathbb{R}^{p\times p}$. Archival correction. The original general novelty claims are no longer maintained: general DAG-Hessian calculus has prior precedents. This is a corrected archival version.

## Octopus: One Brain, Many Branches for Latent-KV Multi-Agent Reinforcement Learning

DevFeed: [Octopus: One Brain, Many Branches for Latent-KV Multi-Agent Reinforcement Learning](<https://devfeed.tech/articles/octopus-one-brain-many-branches-for-latent-kv-multi-agent-reinforcement-learning-120541.md>)

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

Author: Tianming Sha

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

Content type: article

Language: en

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

Topics: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Reinforcement learning](<https://devfeed.tech/topics/reinforcement-learning.md>), [grpo](<https://devfeed.tech/topics/grpo.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>)

Tags: [agent-frameworks](<https://devfeed.tech/tags/agent-frameworks.md>), [agents](<https://devfeed.tech/tags/agents.md>), [attention](<https://devfeed.tech/tags/attention.md>), [bm25](<https://devfeed.tech/tags/bm25.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [dag](<https://devfeed.tech/tags/dag.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [grpo](<https://devfeed.tech/tags/grpo.md>), [llm](<https://devfeed.tech/tags/llm.md>), [mamba-2](<https://devfeed.tech/tags/mamba-2.md>), [memory](<https://devfeed.tech/tags/memory.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [octopus](<https://devfeed.tech/tags/octopus.md>), [qwen3-5-4b](<https://devfeed.tech/tags/qwen3-5-4b.md>), [radix](<https://devfeed.tech/tags/radix.md>), [reinforcement-learning](<https://devfeed.tech/tags/reinforcement-learning.md>), [rl](<https://devfeed.tech/tags/rl.md>), [sparse-attention](<https://devfeed.tech/tags/sparse-attention.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [trainer](<https://devfeed.tech/tags/trainer.md>), [training](<https://devfeed.tech/tags/training.md>)

### AI overview

Octopus coordinates multi-agent reinforcement learning through a GPU-resident DAG of shared KV states, letting branches share a model backbone and reuse cache state. Its three mechanisms are zero-copy radix forks, attention-only mounting of sibling KV blocks (bypassing recurrent states), and a packed DAG-GRPO trainer that assigns branch credit using leave-one-branch-out rewards. The abstract reports that mounting reduces off-task hijacking from 57.9% to 2.7% while retaining 92.2% of full-text mutual information with no extra KV allocation. On Qwen3.5-4B with sparse BM25 retrieval, Octopus reports 49.6% BrowseComp-Plus accuracy--17.5 points above single-agent GRPO and 12.5 above text-summary multi-agent RL--and 51.2% on OpenResearcher. It also reports 3.3x higher training throughput and 2.8x lower peak KV memory. These are abstract-reported results; the supplied text does not provide evaluation details.

### Source excerpt

arXiv:2611.06956v1 Announce Type: new Abstract: Multi-agent LLM systems explore in parallel by spawning sub-agents with isolated context windows, whereas single-agent systems append every search and verification step into one growing trajectory. However, existing multi-agent frameworks duplicate prefix KV caches across branches, exchange findings by re-prefilling text summaries, and flatten or drop cross-branch dependencies during reinforcement learning (RL). We introduce Octopus, a single-model multi-agent RL framework in which all threads share one backbone and coordinate over a GPU-resident directed acyclic graph (DAG) of KV states through five primitives (fork, read_thread, wait_threads, rewind, commit). Octopus combines three co-designed mechanisms: (1) Zero-Copy Radix Forking, which spawns branches as $\mathcal{O}(1)$ cursor views over shared physical KV pages; (2) Attention-Only KV Mounting, which mounts a sibling thread's terminal KV blocks directly into full-attention layers while bypassing linear-recurrent states (Gated DeltaNet / Mamba-2), cutting off-task hijacking by $21\times$ ($57.9\% \to 2.7\%$) while retaining $92.2\%$ of full-text mutual information at zero extra KV allocation; and (3) a Packed DAG-GRPO Trainer, which packs all episode branches into one block-sparse attention pass and assigns counterfactual branch credit via leave-one-branch-out marginal rewards. Trained end-to-end with GRPO on Qwen3.5-4B over a sparse BM25 corpus, Octopus reaches $49.6\%$ accuracy on BrowseComp-Plus ($+17.5$ points over single-agent GRPO at 143K context and $+12.5$ points over text-summary multi-agent RL) and $51.2\%$ on OpenResearcher, outperforming dense-retrieval agents up to $250\times$ larger while increasing training throughput $3.3\times$ and cutting peak KV memory $2.8\times$.

## DTA-GT: Direction- and Topology-Aware Graph Transformer for Neural Network Representation Learning

DevFeed: [DTA-GT: Direction- and Topology-Aware Graph Transformer for Neural Network Representation Learning](<https://devfeed.tech/articles/dta-gt-direction-and-topology-aware-graph-transformer-for-neural-network-representation-learning-118275.md>)

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

Author: Yuxiang Zeng, Kun Xie, Yang Wang, Jigang Wen, Xiaocan Li, Guangxing Zhang, Gaogang Xie, Jiannong Cao

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

Content type: article

Language: en

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

Topics: [Transformer](<https://devfeed.tech/topics/transformer.md>), [Representation learning](<https://devfeed.tech/topics/representation-learning.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [graph theory](<https://devfeed.tech/topics/graph-theory.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [attention](<https://devfeed.tech/tags/attention.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-ne](<https://devfeed.tech/tags/cs-ne.md>), [dag](<https://devfeed.tech/tags/dag.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [execution](<https://devfeed.tech/tags/execution.md>), [gnn](<https://devfeed.tech/tags/gnn.md>), [graph](<https://devfeed.tech/tags/graph.md>), [latency](<https://devfeed.tech/tags/latency.md>), [learning](<https://devfeed.tech/tags/learning.md>), [moe](<https://devfeed.tech/tags/moe.md>), [nas](<https://devfeed.tech/tags/nas.md>), [network](<https://devfeed.tech/tags/network.md>), [neural](<https://devfeed.tech/tags/neural.md>), [neural-network](<https://devfeed.tech/tags/neural-network.md>), [node](<https://devfeed.tech/tags/node.md>), [orientation](<https://devfeed.tech/tags/orientation.md>), [prediction](<https://devfeed.tech/tags/prediction.md>), [topology](<https://devfeed.tech/tags/topology.md>), [transformer](<https://devfeed.tech/tags/transformer.md>)

### AI overview

DTA-GT predicts neural architecture accuracy and latency by coordinating directed-graph semantics across node initialization, Magnetic Laplacian spectral encoding, direction-dual structural attention, and a Direction-Sensitive MoE-FFN. On NAS-Bench-101 and NAS-Bench-201, it reportedly outperforms representative sequence, GNN, Transformer, and hybrid predictors in limited-budget settings. Ablations and spectral controls support contributions from its direction-aware stages and orientation-sensitive spectral information. The supplied text is an abstract, so it does not provide detailed results or comparisons.

### Source excerpt

arXiv:2610.16822v2 Announce Type: replace-cross Abstract: Architecture attribute predictors reduce the cost of neural architecture search by estimating accuracy or latency from a small set of evaluated candidates. Neural architectures are operation-labeled directed acyclic graphs (DAGs), where edge directions determine computational roles and execution dependencies. Existing graph Transformer predictors incorporate topological and directional information in different ways, but primarily focus on specific mechanisms rather than coordinated encoder-wide modeling of these semantics. We introduce encoder-wide directional consistency, a design principle that coordinates the modeling of directed computational semantics across node initialization, global spectral encoding, pairwise interaction, and feature updates. To implement this principle, we propose DTA-GT, a Direction- and Topology-Aware Graph Transformer that integrates direction- and topology-aware node initialization, Magnetic Laplacian spectral encoding, direction-dual structural attention, and a Direction-Sensitive MoE-FFN. Across accuracy and latency prediction on NAS-Bench-101 and NAS-Bench-201, DTA-GT consistently outperforms representative sequence-, GNN-, Transformer-, and hybrid predictors under limited-budget settings. Ablations and Magnetic spectral controls support the contribution of the direction-aware stages and orientation-sensitive spectral information, while mechanistic diagnostics characterize module behavior. These results support encoder-wide directional consistency as an effective design principle for architecture DAG representation.

## Throughput-Optimal Control of Distributed Computing Networks for Service DAGs

DevFeed: [Throughput-Optimal Control of Distributed Computing Networks for Service DAGs](<https://devfeed.tech/articles/throughput-optimal-control-of-distributed-computing-networks-for-service-dags-116526.md>)

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

Author: Peng Li, Jianan Zhang, Jaime Llorca, Xinzhe Fu, Xiang Cheng, Chen Chen

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

Content type: article

Language: en

Sources: [arXiv: Networking](<https://devfeed.tech/sources/arxiv-networking.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [queueing theory](<https://devfeed.tech/topics/queueing-theory.md>), [Combinatorial optimization](<https://devfeed.tech/topics/combinatorial-optimization.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [cs-ni](<https://devfeed.tech/tags/cs-ni.md>), [dag](<https://devfeed.tech/tags/dag.md>), [distributed-computing](<https://devfeed.tech/tags/distributed-computing.md>), [networks](<https://devfeed.tech/tags/networks.md>), [optimal-control](<https://devfeed.tech/tags/optimal-control.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [wireless](<https://devfeed.tech/tags/wireless.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

The paper presents DCNC-DAG for executing service DAGs over wireless computing networks with stochastic arrivals, changing links, and interference. It maps functions to computation nodes and dependencies to routes, then uses queue-aware mappings and nearest-to-origin scheduling while synchronizing request inputs at merge points. The authors state that synchronization does not reduce the capacity region. With exact minimum-cost mappings, the policy is throughput-optimal and keeps physical queues rate-stable under bounded arrivals, even with finite mapping-update intervals and boundedly stale queue information. For larger DAGs, DCNC-DAG-H uses a queue-aware heuristic instead of exact optimization. Simulations report 2.7-5.5 times the throughput of queue-blind baselines for DCNC-DAG and up to 2.68 times that of corresponding baselines for DCNC-DAG-H.

### Source excerpt

arXiv:2611.05007v1 Announce Type: new Abstract: Executing service workflows with directed acyclic graph (DAG) dependencies over wireless distributed computing networks requires joint control of function placement, routing, and scheduling, together with synchronization of inputs from the same request at merge points. We study throughput-optimal control of these networks under stochastic request arrivals, time-varying wireless links, and interference constraints. We use a valid mapping abstraction that assigns each service function to a computation node and each DAG dependency to a routing path. Using this abstraction, we characterize the network capacity region to support service DAGs, and prove that synchronizing the packets of a request at merge points does not shrink the region. We develop Dynamic Computing Network Control for service DAGs (DCNC-DAG), a dynamic control policy that selects queue-aware valid mappings and schedules service DAG execution by nearest-to-origin (NTO) while enforcing input synchronization at merge points. With exact minimum-cost valid mappings, DCNC-DAG is throughput-optimal and ensures rate stability of the physical queues under bounded arrivals. These guarantees hold for any fixed finite interval between mapping updates, even when mapping decisions rely on boundedly stale queue length information. For larger service DAGs, we develop DCNC-DAG-H, which replaces exact mapping optimization with a queue-aware heuristic. Simulations show that DCNC-DAG supports $2.7\times$-$5.5\times$ the throughput of queue-blind baselines, while DCNC-DAG-H achieves up to $2.68\times$ those of the corresponding baselines on larger workflow and AI service DAGs.

## Lifefin: Escaping Mempool Explosions in DAG-based BFT

DevFeed: [Lifefin: Escaping Mempool Explosions in DAG-based BFT](<https://devfeed.tech/articles/lifefin-escaping-mempool-explosions-in-dag-based-bft-113977.md>)

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

Author: Jianting Zhang, Sen Yang, Alberto Sonnino, Sebasti\\'an Loza, Aniket Kate

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

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Resilience](<https://devfeed.tech/topics/resilience.md>), [cyber resiliency](<https://devfeed.tech/topics/cyber-resiliency.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [adversary](<https://devfeed.tech/tags/adversary.md>), [attacks](<https://devfeed.tech/tags/attacks.md>), [changes](<https://devfeed.tech/tags/changes.md>), [compare](<https://devfeed.tech/tags/compare.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [dag](<https://devfeed.tech/tags/dag.md>), [data](<https://devfeed.tech/tags/data.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [existing](<https://devfeed.tech/tags/existing.md>), [generic](<https://devfeed.tech/tags/generic.md>), [implement](<https://devfeed.tech/tags/implement.md>), [integrate](<https://devfeed.tech/tags/integrate.md>), [mechanism](<https://devfeed.tech/tags/mechanism.md>), [message](<https://devfeed.tech/tags/message.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [resource](<https://devfeed.tech/tags/resource.md>), [throughput](<https://devfeed.tech/tags/throughput.md>)

### AI overview

The abstract identifies a liveness vulnerability in DAG-based BFT protocols: an adversary can trigger mempool explosions that prevent transactions from being committed. Lifefin is a generic, self-stabilizing addition that uses Agreement on Common Subset (ACS) to let nodes commit transactions with bounded resource use under adverse conditions. The authors report almost zero overhead in typical cases. Implementations for Sailfish and Mysticeti achieved comparable throughput to their original versions, with minimal additional latency while resisting similar attacks.

### Source excerpt

arXiv:2511.15936v3 Announce Type: replace Abstract: Directed Acyclic Graph (DAG)-based Byzantine Fault-Tolerant (BFT) protocols have emerged as promising solutions for high-throughput blockchains. By decoupling data dissemination from transaction ordering and constructing a well-connected DAG in the mempool, these protocols enable zero-message ordering and implicit view changes. However, we identify a fundamental liveness vulnerability: an adversary can trigger mempool explosions to prevent transaction commitment, ultimately compromising the protocol's liveness. In response, this work presents Lifefin, a generic and self-stabilizing protocol designed to integrate seamlessly with existing DAG-based BFT protocols and circumvent such vulnerabilities. Lifefin leverages the Agreement on Common Subset (ACS) mechanism, allowing nodes to escape mempool explosions by committing transactions with bounded resource usage even in adverse conditions. As a result, Lifefin imposes (almost) zero overhead in typical cases while effectively eliminating liveness vulnerabilities. To demonstrate the effectiveness of Lifefin, we integrate it into two state-of-the-art DAG-based BFT protocols, Sailfish and Mysticeti, resulting in two enhanced variants: Sailfish-Lifefin and Mysticeti-Lifefin. We implement these variants and compare them with the original Sailfish and Mysticeti systems. Our evaluation demonstrates that Lifefin achieves comparable transaction throughput while introducing only minimal additional latency to resist similar attacks.

## MERIS: Adaptive Real-Time Scheduling of Refined Inference DAGs in Dynamic Robotic Environments

DevFeed: [MERIS: Adaptive Real-Time Scheduling of Refined Inference DAGs in Dynamic Robotic Environments](<https://devfeed.tech/articles/meris-adaptive-real-time-scheduling-of-refined-inference-dags-in-dynamic-robotic-environments-113468.md>)

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

Author: Zexin Li, Tao Ren, Johnathan Liu, Xiaoxi He, Cong Liu

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

Content type: article

Language: en

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

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [autonomous vehicles](<https://devfeed.tech/topics/autonomous-vehicles.md>), [Jetson Orin](<https://devfeed.tech/topics/jetson-orin.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [admission](<https://devfeed.tech/tags/admission.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-driving](<https://devfeed.tech/tags/autonomous-driving.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [completion](<https://devfeed.tech/tags/completion.md>), [compute](<https://devfeed.tech/tags/compute.md>), [cs-ro](<https://devfeed.tech/tags/cs-ro.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [dag](<https://devfeed.tech/tags/dag.md>), [decoder](<https://devfeed.tech/tags/decoder.md>), [dnn](<https://devfeed.tech/tags/dnn.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [effectiveness](<https://devfeed.tech/tags/effectiveness.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [execution](<https://devfeed.tech/tags/execution.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [framework](<https://devfeed.tech/tags/framework.md>), [graph](<https://devfeed.tech/tags/graph.md>), [inference](<https://devfeed.tech/tags/inference.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [robotic](<https://devfeed.tech/tags/robotic.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>)

### AI overview

MERIS schedules changing inference workloads on resource-constrained robots by refining task graphs, assigning proportional intermediate deadlines, and synchronizing events. Its end-to-end deadline argument depends on profiled execution bounds, release assumptions, precedence barriers, and per-level capacity premises. For non-partitionable tasks, it uses a profile-bounded admission rule, with direct per-task completion checks needed to establish empirical timing evidence. Evaluation reports run-level QoE separately from the rate of offered nodes missing their deadlines, and describes a minibenchmark for DNN-driven autonomous driving schedulers. Experiments are reported on Nano Orin, AGX Orin, and M3 Max; the supplied excerpt gives no quantitative results.

### Source excerpt

arXiv:2605.24044v2 Announce Type: replace-cross Abstract: Robots deployed in dynamic environments execute changing directed-acyclic-graph (DAG) workloads under limited compute and timing budgets. This article presents MERIS, a framework for model scheduling under real-time constraints that combines proportional intermediate deadlines, MIMONet-aware graph refinement, and event-driven synchronization for multi-task inference on resource-constrained robotic platforms. We distinguish three representations: the application DAG, each MIMONet's internal encoder/decoder graph, and the refined scheduling DAG, and make the scope of the timing argument explicit. If the profiled execution bounds, release assumptions, precedence barriers, and per-level capacity premises hold, satisfaction of the assigned sub-deadlines composes to the end-to-end deadline. For non-partitionable tasks, we define a profile-bounded admission rule; before interpreting that rule as empirical timing evidence, we require direct per-task completion checks. We report run-level QoE alongside the offered-node deadline missing rate, making explicit that run completion and successful service of every node are different outcomes. We propose a comprehensive minibenchmark for evaluating the performance of schedulers under various DNN-driven autonomous driving scenarios. Extensive experiments on Nano Orin, AGX Orin, and M3 Max demonstrate the effectiveness of our proposed method.

## A Deterministic Commitment Rule over Unstructured DAGs for Optimistic Replication

DevFeed: [A Deterministic Commitment Rule over Unstructured DAGs for Optimistic Replication](<https://devfeed.tech/articles/a-deterministic-commitment-rule-over-unstructured-dags-for-optimistic-replication-111758.md>)

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

Author: Jo\\~ao Paulo Bezerra, Petr Kuznetsov, L\\'eo Olivier, Sara Tucci-Piergiovanni

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

Content type: article

Language: en

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

Topics: [consistency](<https://devfeed.tech/topics/consistency.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [allows](<https://devfeed.tech/tags/allows.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [based](<https://devfeed.tech/tags/based.md>), [basic](<https://devfeed.tech/tags/basic.md>), [broadcast](<https://devfeed.tech/tags/broadcast.md>), [can](<https://devfeed.tech/tags/can.md>), [causality](<https://devfeed.tech/tags/causality.md>), [client](<https://devfeed.tech/tags/client.md>), [clients](<https://devfeed.tech/tags/clients.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dag](<https://devfeed.tech/tags/dag.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [framework](<https://devfeed.tech/tags/framework.md>), [free](<https://devfeed.tech/tags/free.md>), [local](<https://devfeed.tech/tags/local.md>), [making](<https://devfeed.tech/tags/making.md>), [over](<https://devfeed.tech/tags/over.md>), [replication](<https://devfeed.tech/tags/replication.md>)

### AI overview

The paper presents a framework for optimistic replication in which each replica executes client requests locally without waiting for synchronization, so results remain subject to later revision. Replicas represent object state as a causally ordered set of operations in a DAG. A deterministic commitment rule lets replicas agree on state evolution, with the abstract claiming virtually no message overhead beyond disseminating submitted operations. The supplied text does not describe the rule's details or evaluation.

### Source excerpt

arXiv:2610.41837v1 Announce Type: new Abstract: In optimistic replication protocols, each replica uses the local state to execute requests from its clients in a wait-free manner, without synchronizing with other replicas. The outcomes may be revised later, making optimistic protocols only eventually consistent. To compensate for this consistency loss, an additional commitment mechanism can be employed: an underlying atomic broadcast protocol that allows replicas to periodically agree on the evolution of the object state. In this paper, we introduce a simple framework for optimistic replication based on a causality DAG: every replica represents the object state via a causally ordered set of client operations. The framework incorporates a deterministic commitment rule that incurs virtually zero message overhead beyond the basic dissemination of submitted operations.

## GearUp: DAG-aware Acceleration for Serverless Inference Serving via Slack-guided Pre-loading

DevFeed: [GearUp: DAG-aware Acceleration for Serverless Inference Serving via Slack-guided Pre-loading](<https://devfeed.tech/articles/gearup-dag-aware-acceleration-for-serverless-inference-serving-via-slack-guided-pre-loading-107568.md>)

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

Author: Qi Qi, Yifan Sui, Hanfei Yu, Hong Zhang, Hao Wang

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

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

Topics: [model-serving](<https://devfeed.tech/topics/model-serving.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [lazy loading](<https://devfeed.tech/topics/lazy-loading.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>)

Tags: [acceleration](<https://devfeed.tech/tags/acceleration.md>), [adaptive](<https://devfeed.tech/tags/adaptive.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-os](<https://devfeed.tech/tags/cs-os.md>), [dag](<https://devfeed.tech/tags/dag.md>), [inference](<https://devfeed.tech/tags/inference.md>), [loading](<https://devfeed.tech/tags/loading.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [serverless-inference](<https://devfeed.tech/tags/serverless-inference.md>), [serving](<https://devfeed.tech/tags/serving.md>), [slack](<https://devfeed.tech/tags/slack.md>)

### AI overview

GearUp hides machine-learning node initialization from a serverless inference DAG's critical path by profiling library, model-weight, and CUDA-kernel loading and scheduling it during upstream execution slack. It reuses initialized instances across requests and applies a probabilistic, traffic-adaptive keep-alive policy to trade idle memory use against cold-start risk. In tests on AMBER Alert and FINRA-ML with NVIDIA L40S GPUs, it cut median end-to-end latency by 64.5% and 75.9% versus SMIless, with median speedups of 3.1x and 10.0x over cold execution. Versus InstaInfer's eager pre-loading, integrated GPU and host memory allocation fell by up to 83.9% and 94.6%. The paper also reports 4.2x strong scaling on four workers.

### Source excerpt

arXiv:2610.38196v1 Announce Type: new Abstract: Serverless platforms increasingly host machine learning (ML) inference workflows, modeled as directed acyclic graphs (DAGs) of interdependent functions. Beyond container startup, each ML node must load libraries, model weights, and CUDA kernels before it can run. These costs accumulate along dependent DAG paths and place initialization on the end-to-end critical path. Existing systems optimize one half of this problem. DAG-agnostic pre-loading prepares nodes the request may never reach, wasting host and GPU memory. DAG-aware serving routes and scales whole functions, leaving the loading stages inside a node untouched. This paper presents GearUp, a serverless DAG inference serving system that removes ML-node loading from the end-to-end critical path at low resource cost. GearUp profiles the loading stages of each node and schedules them inside the slack time the DAG exposes, hiding initialization behind upstream execution. It reuses initialized instances within and across requests to avoid redundant cold starts. A probabilistic, traffic-adaptive keep-alive policy sets how long idle instances are retained, balancing memory cost against cold-start risk under bursty load. On the AMBER Alert and FINRA-ML workflows with NVIDIA L40S GPUs, GearUp reduces median end-to-end latency by 64.5% and 75.9% against SMIless, for median speedups of 3.1x and 10.0x over cold execution. Integrated GPU and host memory allocation fall by up to 83.9% and 94.6% against eager pre-loading in InstaInfer. GearUp achieves 4.2x strong scaling on four workers.

## From Ripple to Boundary: Deterministic Impact Boundaries for LLM-Based Software Evolution

DevFeed: [From Ripple to Boundary: Deterministic Impact Boundaries for LLM-Based Software Evolution](<https://devfeed.tech/articles/from-ripple-to-boundary-deterministic-impact-boundaries-for-llm-based-software-evolution-103643.md>)

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

Author: Jiameng Bai, Zhitao Wang, Long Wang, Keyue Qian, Sai Wu

Published: 2026-10-28T04:00:00Z

Content type: article

Language: en

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

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Model driven development](<https://devfeed.tech/topics/model-driven-development.md>), [context-architecture](<https://devfeed.tech/topics/context-architecture.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [asset](<https://devfeed.tech/tags/asset.md>), [change](<https://devfeed.tech/tags/change.md>), [code](<https://devfeed.tech/tags/code.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [context](<https://devfeed.tech/tags/context.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dag](<https://devfeed.tech/tags/dag.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [design](<https://devfeed.tech/tags/design.md>), [effect](<https://devfeed.tech/tags/effect.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [graph](<https://devfeed.tech/tags/graph.md>), [hash](<https://devfeed.tech/tags/hash.md>), [impact](<https://devfeed.tech/tags/impact.md>), [llm](<https://devfeed.tech/tags/llm.md>), [ripple](<https://devfeed.tech/tags/ripple.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

The paper proposes a deterministic way to identify which generated code should change when a design asset is updated. It represents design assets as a Knowledge Graph organized into a content-addressed Merkle DAG, then uses two-phase diffing to trace a causal chain and define a modification boundary. The authors say this boundary lets an LLM receive narrowly scoped code and design context, addressing risks they attribute to probabilistic retrieval and text-based diffing: missing required changes or altering unrelated code. The Knowledge Graph also supports natural-language design retrieval. The abstract reports early deployment on an industrial payment platform, where the mechanism computed impact boundaries and generated incremental modifications matching expected design changes; it provides no further evaluation details.

### Source excerpt

arXiv:2610.36549v1 Announce Type: new Abstract: The landscape of software evolution is undergoing a fundamental paradigm shift in the era of Large Language Models. As industrial software engineering increasingly transitions toward design-driven code generation, the bottleneck of evolution has shifted from writing code to maintaining deterministic consistency between multi-source design assets and the generated code. When a design asset changes, LLM agents currently lack a deterministic impact boundary to identify which code must be evolved, leading to two failure modes: hallucinating missing changes or breaking unrelated code. Probabilistic approaches, such as semantic retrieval or text-based diffing, fail to capture the structural ripple effects across highly interconnected design dependencies. We propose a paradigm shift from probabilistic semantic retrieval to deterministic structural constraints. We formalize the design assets as a Knowledge Graph and organize them into a content-addressed Merkle Directed Acyclic Graph. Our key insight reveals a topological isomorphism between the logical ripple effect of a design change and the content hash propagation within the DAG. By leveraging this, we transform ambiguous impact analysis into verifiable structural operations. Through a two-phase diffing process, we extract a precise causal chain that defines the exact modification boundary. This boundary enables deterministic context injection, providing the LLM agent with strictly scoped code and design updates, thereby fundamentally guaranteeing evolution safety. As a by-product, the KG serves as an agent-queryable knowledge base for natural language design retrieval. Early deployment on a large-scale industrial payment platform demonstrates that our mechanism successfully computes the exact impact boundary and generates incremental code modifications that meet the expected design changes.

## QTUNER: A Feature-Guided Adaptive Framework for Quantum-Compiler Optimization Pass Tuning

DevFeed: [QTUNER: A Feature-Guided Adaptive Framework for Quantum-Compiler Optimization Pass Tuning](<https://devfeed.tech/articles/qtuner-a-feature-guided-adaptive-framework-for-quantum-compiler-optimization-pass-tuning-103606.md>)

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

Author: Ming Zhong, Xiangyu Ren, Jinglei Cheng, Shaohua Li, Zhiding Liang

Published: 2026-10-28T04:00:00Z

Content type: article

Language: en

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

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Hyperparameter optimization](<https://devfeed.tech/topics/hyperparameter-optimization.md>), [Feature Engineering](<https://devfeed.tech/topics/feature-engineering.md>)

Tags: [2q](<https://devfeed.tech/tags/2q.md>), [adaptive](<https://devfeed.tech/tags/adaptive.md>), [bayesian](<https://devfeed.tech/tags/bayesian.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [circuit](<https://devfeed.tech/tags/circuit.md>), [circuits](<https://devfeed.tech/tags/circuits.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-optimization](<https://devfeed.tech/tags/compiler-optimization.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dag](<https://devfeed.tech/tags/dag.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [effectiveness](<https://devfeed.tech/tags/effectiveness.md>), [embeddings](<https://devfeed.tech/tags/embeddings.md>), [execution](<https://devfeed.tech/tags/execution.md>), [feature](<https://devfeed.tech/tags/feature.md>), [features](<https://devfeed.tech/tags/features.md>), [framework](<https://devfeed.tech/tags/framework.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [pass](<https://devfeed.tech/tags/pass.md>), [quant-ph](<https://devfeed.tech/tags/quant-ph.md>), [quantum](<https://devfeed.tech/tags/quantum.md>)

### AI overview

QTuner uses circuit features tied to optimization behavior to find promising quantum-compiler pass sequences. It builds a dataset of sequences found by Bayesian Optimization, combines static circuit features with optimization-aware pass embeddings, and trains two offline models to retrieve and rank candidates for new circuits. Across two benchmarks, Qiskit results show up to a 10.6 percentage-point improvement in 2Q gate reduction over the strongest baseline while cutting tuning time by 73.59%; PyTKET results show up to a 9.4-point improvement and a 64.49% time reduction. The supplied abstract does not detail the benchmarks or evaluation conditions.

### Source excerpt

arXiv:2607.04586v2 Announce Type: replace-cross Abstract: Quantum compiler optimization is important for improving the execution fidelity of quantum circuits. In practice, this optimization is often formulated as reducing circuit-level metrics. In classical compilers, pass tuning has been well-established through various methods. However, these methods cannot be directly applied to quantum compilers, because quantum programs exhibit quantum-specific features. Existing quantum compiler tuning studies have attempted to incorporate quantum circuit features with compiler tuning techniques, but they still suffer from two key limitations. First, they tune only a limited subset of optimization passes, leaving the global effectiveness of the full optimization pass space underexplored. Second, the quantum features they use are mainly static features, such as structure and DAG features, which are not directly tied to the optimization characteristics of quantum circuits. In this paper, we propose QTuner, a feature-guided framework for quantum compiler pass tuning. We first construct an optimization dataset by performing Bayesian Optimization and recording their optimized pass sequences. Based on this dataset, QTuner represents each circuit with two types of features: static circuit features and optimization-aware pass embeddings. Finally, QTuner trains two models offline, which are used to efficiently retrieve and rank promising pass sequences for a new circuit. We evaluate QTuner on two benchmarks across Qiskit and PyTKET compilers. On Qiskit, QTuner achieves up to a 10.6-percentage-point improvement in 2Q gate reduction over the strongest baseline while reducing tuning time by 73.59%. On PyTKET, QTuner achieves up to a 9.4-percentage-point improvement in 2Q gate reduction and reduces tuning time by 64.49%. These results demonstrate that QTuner enables efficient pass tuning across quantum compilers.

## Causal DAG-Guided Reinforcement Learning for Long-Term Physical Activity Maintenance: Using Prior Data to Inform Future Deployment

DevFeed: [Causal DAG-Guided Reinforcement Learning for Long-Term Physical Activity Maintenance: Using Prior Data to Inform Future Deployment](<https://devfeed.tech/articles/causal-dag-guided-reinforcement-learning-for-long-term-physical-activity-maintenance-using-prior-data-to-inform-future-deployment-103905.md>)

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

Author: Xueqing Liu, Young Hyun Cho, Bhanu Teja Gullapalli, Predrag Klasnja, Susan Murphy

Published: 2026-10-28T04:00:00Z

Content type: article

Language: en

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

Topics: [Reinforcement learning](<https://devfeed.tech/topics/reinforcement-learning.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [can](<https://devfeed.tech/tags/can.md>), [candidate](<https://devfeed.tech/tags/candidate.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [change](<https://devfeed.tech/tags/change.md>), [compare](<https://devfeed.tech/tags/compare.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [dag](<https://devfeed.tech/tags/dag.md>), [daily](<https://devfeed.tech/tags/daily.md>), [data](<https://devfeed.tech/tags/data.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [design](<https://devfeed.tech/tags/design.md>), [designs](<https://devfeed.tech/tags/designs.md>), [digital](<https://devfeed.tech/tags/digital.md>), [future](<https://devfeed.tech/tags/future.md>), [learning](<https://devfeed.tech/tags/learning.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [reinforcement-learning](<https://devfeed.tech/tags/reinforcement-learning.md>), [stat-ap](<https://devfeed.tech/tags/stat-ap.md>), [using](<https://devfeed.tech/tags/using.md>)

### AI overview

The paper describes an online reinforcement learning system for a forthcoming trial that personalizes twice-daily physical activity suggestions to improve affective experiences associated with sustained activity. To address sparse participant-specific data, partially observed states and rewards, weekly outcomes despite frequent interventions, and possible intervention burden, the authors use an expert-specified causal DAG to guide state construction, estimation of hidden states, delayed credit assignment, and modeling beneficial and adverse intervention pathways. They also build a longitudinal simulator calibrated with data from a prior micro-randomized trial to compare candidate designs under realistic evolution, missingness, and participant heterogeneity before deployment.

### Source excerpt

arXiv:2610.36019v1 Announce Type: cross Abstract: Digital health interventions can provide scalable, personalized support for physical activity (PA), yet sustaining PA over the long-term remains difficult. Because affective experiences with PA are important for activity sustainment, we developed an online reinforcement learning (RL) system for the forthcoming ADAPT factorial trial that personalizes twice-daily activity suggestions aimed at improving affective associations with PA. This setting poses several challenges: participant-specific data are scarce relative to the candidate state space, important states and rewards are partially observed, interventions are frequent while the primary outcome is measured weekly, and activity suggestions can both improve PA-related experiences and increase intervention burden. We address these challenges using an expert-specified causal directed acyclic graph as an integrated RL design tool, guiding state construction, estimation of partially observed states, delayed credit assignment, and representation of beneficial and adverse intervention pathways. We further construct a longitudinal simulator calibrated from a prior micro-randomized trial to compare candidate RL designs under realistic state evolution, missingness, and participant heterogeneity before deployment. Together, this work illustrates how causal domain knowledge and prior trial data can make long-horizon, participant-specific RL more practical for digital health interventions targeting sustained behavior change.

## How Sweetwater catches broken dbt pipelines before anyone notices, with Datadog

DevFeed: [How Sweetwater catches broken dbt pipelines before anyone notices, with Datadog](<https://devfeed.tech/articles/how-sweetwater-catches-broken-dbt-pipelines-before-anyone-notices-with-datadog-102654.md>)

Original publisher: [Read original article](<https://www.getdbt.com/blog/sweetwater-dbt-pipeline-monitoring-datadog>)

Author: Daniel Poppy

Published: 2026-10-27T18:08:00Z

Content type: news

Language: en

Sources: [dbt Labs](<https://devfeed.tech/sources/dbt-labs.md>)

Topics: [data observability](<https://devfeed.tech/topics/data-observability.md>), [datadog](<https://devfeed.tech/topics/datadog.md>), [Data pipelines](<https://devfeed.tech/topics/data-pipelines.md>), [Apache Kafka](<https://devfeed.tech/topics/apache-kafka.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [alert](<https://devfeed.tech/tags/alert.md>), [alerting](<https://devfeed.tech/tags/alerting.md>), [ci-cd](<https://devfeed.tech/tags/ci-cd.md>), [cli](<https://devfeed.tech/tags/cli.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [dag](<https://devfeed.tech/tags/dag.md>), [dashboard](<https://devfeed.tech/tags/dashboard.md>), [dashboards](<https://devfeed.tech/tags/dashboards.md>), [data-infrastructure](<https://devfeed.tech/tags/data-infrastructure.md>), [data-observability](<https://devfeed.tech/tags/data-observability.md>), [data-platform](<https://devfeed.tech/tags/data-platform.md>), [data-warehouse](<https://devfeed.tech/tags/data-warehouse.md>), [datadog](<https://devfeed.tech/tags/datadog.md>), [dbt](<https://devfeed.tech/tags/dbt.md>), [learn](<https://devfeed.tech/tags/learn.md>), [missing-data](<https://devfeed.tech/tags/missing-data.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>)

### AI overview

Sweetwater extended Datadog monitoring into its dbt pipelines as its data platform grew, building on the tool already used by IT to monitor source systems. In a recurring sales dashboard issue, data appeared fresh even though invoices lacked sales channels. Kafka insert dashboards helped the team trace a transaction spike to a websql source and an incorrectly scheduled legacy script; they rescheduled it and began considering a move to the cloud warehouse. Datadog's Google Cloud integrations and prebuilt metrics also helped the team manage timeout risk as DAGs and batch demands grew. Its setup includes schema- and database-wide monitors, table-adjusted row count checks, freshness checks that allow planned nightly downtime, team-specific alert and recovery routing, and machine-learning thresholds with manual annotations. The team is expanding into lineage and query monitoring, terminal and AI-assistant access through PupCLI and the Datadog MCP server, and CI/CD impact analysis and data profiling for changed models.

### Source excerpt

Sweetwater uses Datadog to catch broken dbt pipelines before dashboard users notice missing data.

## FaaSpot: Fault-Tolerant Serverless Workflow Execution on Spot Instances

DevFeed: [FaaSpot: Fault-Tolerant Serverless Workflow Execution on Spot Instances](<https://devfeed.tech/articles/faaspot-fault-tolerant-serverless-workflow-execution-on-spot-instances-101593.md>)

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

Author: Bandhan Patel, Sushruth Harsha, Kwangsung Oh, In Kee Kim

Published: 2026-10-27T04:00:00Z

Content type: article

Language: en

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

Topics: [Serverless](<https://devfeed.tech/topics/serverless.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Deployment & Scaling](<https://devfeed.tech/topics/deployment-scaling.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>)

Tags: [cascade](<https://devfeed.tech/tags/cascade.md>), [classification](<https://devfeed.tech/tags/classification.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dag](<https://devfeed.tech/tags/dag.md>), [emulator](<https://devfeed.tech/tags/emulator.md>), [execution](<https://devfeed.tech/tags/execution.md>), [failure](<https://devfeed.tech/tags/failure.md>), [fallback](<https://devfeed.tech/tags/fallback.md>), [fan](<https://devfeed.tech/tags/fan.md>), [function](<https://devfeed.tech/tags/function.md>), [latency](<https://devfeed.tech/tags/latency.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [retry](<https://devfeed.tech/tags/retry.md>), [scaling](<https://devfeed.tech/tags/scaling.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [topology](<https://devfeed.tech/tags/topology.md>), [trace](<https://devfeed.tech/tags/trace.md>), [workflow](<https://devfeed.tech/tags/workflow.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

FaaSpot aims to make serverless workflows resilient to spot-instance preemption without using on-demand fallback. It analyzes a workflow's DAG at submission to classify tasks by how preemption could disrupt the workflow; selective checkpointing, survival-aware scaling, and lineage-based retry use that classification without runtime coordination. In a trace-driven spot emulator evaluating eight DAG workflows against four baselines, FaaSpot completed 89.03% of runs at $0.018 per successful run. Its success rate was 21 percentage points above the baselines' average, its cost per success was lower than every baseline, and its mean latency was 2.3 times lower.

### Source excerpt

arXiv:2610.26709v2 Announce Type: replace Abstract: Serverless computing is increasingly used to run complex DAG workflows across diverse applications, and individual function execution times have grown to support them, pushing workflow makespans to hours. Open-source serverless platforms, deployed on a pool of VMs, typically use on-demand instances, and their cost increases with the makespan. Spot instances are far cheaper, but a preemption is likely before the workflow finishes. A preemption at a fan-out node or a task feeding a fan-in node stalls every parallel branch, cascading a single preemption into a workflow-wide failure. Prior systems address this challenge by migrating high-impact tasks to reliable, non-spot resources, sacrificing spot's cost advantage. We present FaaSpot, a serverless workflow execution system that runs every workflow task on spot instances with no on-demand fallback. Our key insight is that cascade-prone positions are determined by the DAG's topology and can be identified before execution. Therefore, FaaSpot analyzes the workflow DAG once at submission time and classifies each task by the impact of its preemption. Selective checkpointing, survival-aware scaling, and lineage-based retry then act on this single classification, with no runtime coordination. We evaluate FaaSpot on a trace-driven spot emulator with eight DAG workflows against four state-of-the-art baselines. FaaSpot completes 89.03% of runs at $0.018 per successful run, 21pp (percentage points) above the average baseline success rate and at a lower cost per success than every baseline, while reducing mean latency by 2.3x.

## Finding Nemo-Nemo: CFT DAG-based Consensus in the WAN

DevFeed: [Finding Nemo-Nemo: CFT DAG-based Consensus in the WAN](<https://devfeed.tech/articles/finding-nemo-nemo-cft-dag-based-consensus-in-the-wan-101579.md>)

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

Author: Rithwik Kerur, Pasindu Tennage, Philipp Jovanovic, Dahlia Malkhi, Alberto Sonnino, Igor Zablotchi

Published: 2026-10-27T04:00:00Z

Content type: article

Language: en

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

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

Tags: [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dag](<https://devfeed.tech/tags/dag.md>), [latency](<https://devfeed.tech/tags/latency.md>), [performance](<https://devfeed.tech/tags/performance.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [wan](<https://devfeed.tech/tags/wan.md>)

### AI overview

Nemo-Nemo is a crash-fault-tolerant consensus protocol designed for wide-area networks. It propagates commands through a causally ordered DAG, lets all replicas propose commands, and uses multiple leaders to avoid a single-leader bottleneck. Separating command dissemination from consensus lets propagation continue during stalled commits; proposals that miss deadlines are deterministically deferred rather than dropped. The abstract says Nemo-Nemo commits on the DAG in two network hops, matching existing CFT systems' latency while achieving higher throughput. It does not provide measurements or details of the evaluation.

### Source excerpt

arXiv:2604.08914v3 Announce Type: replace Abstract: This paper introduces Nemo-Nemo, a practical crash-fault tolerant (CFT) consensus protocol designed to outperform existing protocols in wide-area networks by bridging design principles from the CFT and Byzantine-fault tolerant (BFT) worlds. By structuring command propagation through a causally ordered DAG, Nemo-Nemo allows all consensus replicas to propose commands with a naturally self-regulating communication regime. By exploiting multi-leader architecture, Nemo-Nemo avoids the performance bottleneck inherent to single-leader protocols. By separating command dissemination from consensus logic, Nemo-Nemo handles challenging network conditions even when consensus commits are stalled. Moreover, leader proposals that miss a deadline are never dropped, but deterministically deferred and executed later, preserving throughput under transient network delays. And by enabling Nemo-Nemo to commit on a DAG in just two network hops, it matches the latency of existing CFT systems, while achieving significantly higher throughput. The result is a robust, deployable system: the first DAG-based CFT consensus protocol proven to exceed state-of-the-art wide-area network performance in both speed and resilience.

## MANTA: Unlocking DAG Flexibility in Asynchronous BFT

DevFeed: [MANTA: Unlocking DAG Flexibility in Asynchronous BFT](<https://devfeed.tech/articles/manta-unlocking-dag-flexibility-in-asynchronous-bft-101613.md>)

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

Author: Mohan Yu, Chenlin Wu, Jianyu Niu, Cong Wang, Chenyuan Wu

Published: 2026-10-27T04:00:00Z

Content type: article

Language: en

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

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

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [bft-consensus](<https://devfeed.tech/tags/bft-consensus.md>), [block](<https://devfeed.tech/tags/block.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [connectivity](<https://devfeed.tech/tags/connectivity.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dag](<https://devfeed.tech/tags/dag.md>), [deployments](<https://devfeed.tech/tags/deployments.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [flexibility](<https://devfeed.tech/tags/flexibility.md>), [flexible](<https://devfeed.tech/tags/flexible.md>), [framework](<https://devfeed.tech/tags/framework.md>), [graph](<https://devfeed.tech/tags/graph.md>), [growth](<https://devfeed.tech/tags/growth.md>)

### AI overview

MANTA addresses latency from straggler effects in asynchronous DAG-based BFT by relaxing synchronized round advancement: replicas can advance without waiting for every round's reference quorum, while connectivity needed for commitment accumulates across rounds. It pairs flexible DAG growth with a flexible coin intended to trigger leader election and finality earlier. Experiments on heterogeneous WAN deployments report latency reductions of approximately 30%-70% in the authors' evaluation.

### Source excerpt

arXiv:2610.34419v1 Announce Type: new Abstract: DAG-based BFT protocols marked a shift in consensus design by replacing single-leader proposal paths with concurrent block proposals linked through a shared graph, where references encode consensus evidence. However, under heterogeneous wide-area networks (WANs), existing designs suffer from prolonged rounds and degraded performance due to straggler effects. The root cause is rigid round advancement: replicas move in synchronized rounds, waiting for enough references from the previous round before advancing. We propose a flexible DAG growth framework for asynchronous BFT consensus. Our key observation is that while reference quorums are necessary for safety and liveness, they need not block every round advancement. Instead, the connectivity required for commitment can be accumulated across rounds. Within the framework, we instantiate MANTA, which combines flexible DAG growth to advance by relaxing round synchronization and flexible coin to trigger leader election and finality earlier. Experiments on heterogeneous WAN deployments show that MANTA reduces latency by approximately 30%-70% in our evaluation.

## How customer pressure pushed dbt past a cautious platform team at Delivery Hero

DevFeed: [How customer pressure pushed dbt past a cautious platform team at Delivery Hero](<https://devfeed.tech/articles/how-customer-pressure-pushed-dbt-past-a-cautious-platform-team-at-delivery-hero-101833.md>)

Original publisher: [Read original article](<https://www.getdbt.com/blog/delivery-hero-dbt-platform-modernization>)

Author: Daniel Poppy

Published: 2026-10-26T22:19:00Z

Content type: news

Language: en

Sources: [dbt Labs](<https://devfeed.tech/sources/dbt-labs.md>)

Topics: [internal developer platform](<https://devfeed.tech/topics/internal-developer-platform.md>), [platform engineering automation](<https://devfeed.tech/topics/platform-engineering-automation.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [2023](<https://devfeed.tech/tags/2023.md>), [adoption](<https://devfeed.tech/tags/adoption.md>), [airflow](<https://devfeed.tech/tags/airflow.md>), [analysts](<https://devfeed.tech/tags/analysts.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [analytics-engineering](<https://devfeed.tech/tags/analytics-engineering.md>), [api](<https://devfeed.tech/tags/api.md>), [autonomy](<https://devfeed.tech/tags/autonomy.md>), [bigquery](<https://devfeed.tech/tags/bigquery.md>), [cosmos](<https://devfeed.tech/tags/cosmos.md>), [customer](<https://devfeed.tech/tags/customer.md>), [dag](<https://devfeed.tech/tags/dag.md>), [data-platform](<https://devfeed.tech/tags/data-platform.md>), [dbt](<https://devfeed.tech/tags/dbt.md>), [decentralized](<https://devfeed.tech/tags/decentralized.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [delivery-hero](<https://devfeed.tech/tags/delivery-hero.md>), [domain](<https://devfeed.tech/tags/domain.md>), [learn](<https://devfeed.tech/tags/learn.md>), [platform](<https://devfeed.tech/tags/platform.md>), [teams](<https://devfeed.tech/tags/teams.md>)

### AI overview

Delivery Hero's dbt adoption grew from domain teams' needs rather than a platform mandate. Teams began testing dbt in 2023, built their own dbtflow bridge to Airflow, and later retired it when Astronomer's Cosmos offered similar manifest-to-task conversion. The platform team focused on CI workflows, while a merged team's data product builder and Mesh Hub API abstracted dbt for end users. The account describes four trade-offs and responses: centrally governed dbt macros alongside team flexibility; CI-enforced owner tags so failures can be routed; the dbt CLI as a version-controlled alternative to analysts scheduling directly in BigQuery; and dbt tests and unit tests with Cosmos running native Airflow tasks to ease deployment while retaining checks. Shahid's lessons are to adopt tools deliberately, consider both organizational and tool readiness, and treat the platform's golden path as a standard that can evolve.

### Source excerpt

At Delivery Hero, dbt adoption came from customer teams pushing past platform caution, not from a platform mandate.

## Inside dbt Wizard, the AI agent built to show its work

DevFeed: [Inside dbt Wizard, the AI agent built to show its work](<https://devfeed.tech/articles/inside-dbt-wizard-the-ai-agent-built-to-show-its-work-101832.md>)

Original publisher: [Read original article](<https://www.getdbt.com/blog/dbt-wizard-ai-agent-validation-lineage>)

Author: Daniel Poppy

Published: 2026-10-26T22:07:00Z

Content type: news

Language: en

Sources: [dbt Labs](<https://devfeed.tech/sources/dbt-labs.md>)

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [human in the loop agent](<https://devfeed.tech/topics/human-in-the-loop-agent.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [analytics-engineering](<https://devfeed.tech/tags/analytics-engineering.md>), [app](<https://devfeed.tech/tags/app.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [cli](<https://devfeed.tech/tags/cli.md>), [code](<https://devfeed.tech/tags/code.md>), [dag](<https://devfeed.tech/tags/dag.md>), [data](<https://devfeed.tech/tags/data.md>), [dbt](<https://devfeed.tech/tags/dbt.md>), [demo](<https://devfeed.tech/tags/demo.md>), [desktop](<https://devfeed.tech/tags/desktop.md>), [development](<https://devfeed.tech/tags/development.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [harness](<https://devfeed.tech/tags/harness.md>), [impact](<https://devfeed.tech/tags/impact.md>), [learn](<https://devfeed.tech/tags/learn.md>), [production](<https://devfeed.tech/tags/production.md>), [wizard](<https://devfeed.tech/tags/wizard.md>)

### AI overview

dbt Wizard is presented as a dbt-specific agent that validates proposed changes in a development schema before production and shows downstream impact as a DAG for review. Its native metadata engine gives it structured access to a project; validation separates inexpensive checks such as parsing and compiling from costly materialization, and runs in an isolated sub-agent to reduce shared assumptions. The demo showed it surfacing assumptions, catching a metric bug, supporting parallel conversations, and opening a pull request with context. In Q&A, Fivetran's Ryan Eakman said Wizard includes dbt-specific tools without requiring teams to assemble their own MCP servers and skills, while still supporting skills and MCP connections. It also isolates schemas by work tree. Wizard is available in dbt Studio, the dbt platform, and CLI; the desktop app is in private beta. The excerpt reports design partners' claims of 15-20% fewer production incidents, without further methodology.

### Source excerpt

dbt Wizard's designer and engineering lead show how the agent validates its own work before code ever reaches production.

## How Razorpay Moved 2,500 DAGs to Airflow 3, One DAG at a Time

DevFeed: [How Razorpay Moved 2,500 DAGs to Airflow 3, One DAG at a Time](<https://devfeed.tech/articles/how-razorpay-moved-2-500-dags-to-airflow-3-one-dag-at-a-time-100860.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/how-razorpay-moved-2-500-dags-to-airflow-3-one-dag-at-a-time-71419355a07b?source=rss----6407ad2e59af---4>)

Author: Manish Kumar Gupta

Published: 2026-10-26T10:23:23Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>), [blue-green deployment](<https://devfeed.tech/topics/blue-green-deployment.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [versioning](<https://devfeed.tech/topics/versioning.md>)

Tags: [adoption](<https://devfeed.tech/tags/adoption.md>), [airflow](<https://devfeed.tech/tags/airflow.md>), [api](<https://devfeed.tech/tags/api.md>), [api-server](<https://devfeed.tech/tags/api-server.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [batch](<https://devfeed.tech/tags/batch.md>), [bug](<https://devfeed.tech/tags/bug.md>), [ci](<https://devfeed.tech/tags/ci.md>), [code](<https://devfeed.tech/tags/code.md>), [config](<https://devfeed.tech/tags/config.md>), [crash](<https://devfeed.tech/tags/crash.md>), [dag](<https://devfeed.tech/tags/dag.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [data-pipelines](<https://devfeed.tech/tags/data-pipelines.md>), [database](<https://devfeed.tech/tags/database.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [drop-in](<https://devfeed.tech/tags/drop-in.md>), [executor](<https://devfeed.tech/tags/executor.md>), [import](<https://devfeed.tech/tags/import.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>), [software-development](<https://devfeed.tech/tags/software-development.md>)

### AI overview

Razorpay moved its Airflow workloads from 2.10 to 3 through a separate blue-green cluster and per-DAG cutovers, reaching 2,592 migrated DAGs in ten weeks with about 100 engineers. The central operational change is that Airflow 3 tasks send heartbeats, state updates and XCom through the Task Execution API instead of connecting directly to the metadata database. Slow API requests can stall heartbeats and cause running tasks to be failed as zombies; Razorpay split execution traffic from UI and REST traffic, ran at least two execution API replicas, and added availability and heartbeat alerts. The account also describes a scheduler crash loop in 3.2.1 fixed in 3.3.0, silent configuration changes, parser memory and task-pool limits, and migration issues involving missing Variables and Connections. Its practical approach included diffing effective configs, shipping drop-in v3 helper libraries, freezing v2 changes in CI on published dates, and migrating DAGs individually with rollback available.

### Source excerpt

Airflow, the scheduler behind Razorpay's batch data pipelines, now runs on version 3.3, and we led the move from 2.10. It runs more than 2,700 DAGs and about 11,000 task runs a day, and we got there without a big-bang cutover. The official upgrade guide is the place to start for code changes. This post is about what happened when we ran Airflow 3 at that scale: the architecture change behind most of our incidents, how we moved everything one DAG at a time, the tooling that made it easy for other teams, and the checklist we'd follow next time. If you read nothing else In Airflow 3, every running task talks to the API server, not the database. If the API server stalls, running tasks get killed. Run at least two replicas, and give task traffic its own API server deployment so a slow UI page can't fail tasks. Avoid 3.2.1. A scheduler bug there causes a crash loop that never recovers on its own. 3.3.0 fixes it. Diff the config your pods actually run with. Some of our v2 settings vanished during the move, and some keys were renamed with no warning. Go blue-green: run v3 next to v2, move DAGs one at a time, and freeze v2 in CI on published dates. The freeze did more for adoption than any tooling we wrote: about 100 engineers moved 2,500 DAGs in ten weeks. Make migrating an import swap. Bulk migration only took off once we shipped drop-in v3 versions of our internal helper libraries. Airflow in two minutes Airflow runs batch jobs on a schedule. You describe each pipeline in a Python file called a DAG: a set of tasks and the order they run in. For example: "pull yesterday's payments, then build the settlement report, then email it". A few moving parts matter for this post: The scheduler decides which tasks are due. The executor decides where tasks run. On Airflow 2 we used Celery: a fixed fleet of always-on worker processes that pull tasks off a Redis queue. On Airflow 3 we use the Kubernetes executor, which starts a new pod for every task and deletes it afterwards. The meta

## TGR-EvoDAG: A DAG-based Multi-Agent Code Evolution Framework for Generative Recommendation on Tencent

DevFeed: [TGR-EvoDAG: A DAG-based Multi-Agent Code Evolution Framework for Generative Recommendation on Tencent](<https://devfeed.tech/articles/tgr-evodag-a-dag-based-multi-agent-code-evolution-framework-for-generative-recommendation-on-tencent-99995.md>)

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

Author: Junlin He, Junzhang Zhu, Yudong Li, Yihong Tang, Xuefeng Jiang, Wei Ma, Chengxiang Zhuo, Zang Li

Published: 2026-10-26T04:00:00Z

Content type: article

Language: en

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

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [Advanced AI workflows](<https://devfeed.tech/topics/advanced-ai-workflows.md>), [post-training](<https://devfeed.tech/topics/post-training.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [advanced](<https://devfeed.tech/tags/advanced.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [amazon](<https://devfeed.tech/tags/amazon.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [automated](<https://devfeed.tech/tags/automated.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [based](<https://devfeed.tech/tags/based.md>), [bridge](<https://devfeed.tech/tags/bridge.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [dag](<https://devfeed.tech/tags/dag.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [framework](<https://devfeed.tech/tags/framework.md>), [generative](<https://devfeed.tech/tags/generative.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [recommendation](<https://devfeed.tech/tags/recommendation.md>), [tencent](<https://devfeed.tech/tags/tencent.md>)

### AI overview

TGR-EvoDAG applies multi-agent code evolution to generative recommendation's cascaded tokenization, pre-training, and alignment pipeline. It represents evolution as a directed acyclic graph, preserving branches and merging complementary changes; stage-aware cost planning accounts for unequal retraining costs, while active downstream co-adaptation can retain upstream changes that temporarily lower metrics. On public Amazon datasets, it reports offline metric gains up to 37.4% and a 19.7% increase in Agent4Rec simulated user satisfaction over the strongest baseline. In Tencent deployment, it reports a 12.16% relative offline Hit@1 improvement and a statistically significant 0.40% online CTR increase.

### Source excerpt

arXiv:2610.32326v1 Announce Type: new Abstract: Large Language Model (LLM) agents have enabled automated code evolution for algorithm discovery. However, current recursive self-improvement (RSI) research for sequential recommendation faces a dilemma: general-purpose frameworks lack domain-specific feedback, while recommender-specific frameworks rely on linear evolution. Crucially, naively integrating them fails when applied to Generative Recommendation (GR). Unlike end-to-end models, GR relies on a module-cascaded pipeline (tokenization, pre-training, and alignment). In this paradigm, existing evolution methods suffer from: i) cost blindness, squandering budgets by ignoring stage-asymmetric retraining overheads; and ii) short-sighted evaluation, discarding promising upstream innovations that temporarily regress metrics before downstream adaptation. To bridge these gaps, we propose TGR-EvoDAG, a multi-agent code evolution framework tailored for GR. TGR-EvoDAG models code evolution as a Directed Acyclic Graph (DAG) to maintain multiple evolution branches and merge complementary innovations, unifying advanced search with rich GR diagnostic feedback. We further introduce stage-aware cost planning to optimize GPU-hour budgets, and active downstream co-adaptation to navigate temporary regressions and unlock cross-stage gains. On public Amazon datasets, TGR-EvoDAG enables the first autonomous evolution of a complete GR pipeline, improving offline metrics by up to 37.4% and Agent4Rec simulated user satisfaction by 19.7% over the strongest baseline. Furthermore, in industrial deployment on Tencent's large-scale commercial media platform, the evolved GR achieves a 12.16% relative improvement in offline Hit@1 and a statistically significant 0.40% increase in online click-through rate (CTR).

## Contextual Memory Virtualisation: DAG-Based State Management and Structurally Lossless Trimming for LLM Agents

DevFeed: [Contextual Memory Virtualisation: DAG-Based State Management and Structurally Lossless Trimming for LLM Agents](<https://devfeed.tech/articles/contextual-memory-virtualisation-dag-based-state-management-and-structurally-lossless-trimming-for-llm-agents-99773.md>)

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

Author: Cosmo Santoni

Published: 2026-10-26T04:00:00Z

Content type: article

Language: en

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

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

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [agents](<https://devfeed.tech/tags/agents.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [base64](<https://devfeed.tech/tags/base64.md>), [based](<https://devfeed.tech/tags/based.md>), [bloat](<https://devfeed.tech/tags/bloat.md>), [borrowing](<https://devfeed.tech/tags/borrowing.md>), [branch](<https://devfeed.tech/tags/branch.md>), [caching](<https://devfeed.tech/tags/caching.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-hc](<https://devfeed.tech/tags/cs-hc.md>), [cs-os](<https://devfeed.tech/tags/cs-os.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dag](<https://devfeed.tech/tags/dag.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [management](<https://devfeed.tech/tags/management.md>), [memory](<https://devfeed.tech/tags/memory.md>), [state](<https://devfeed.tech/tags/state.md>), [state-management](<https://devfeed.tech/tags/state-management.md>), [trimming](<https://devfeed.tech/tags/trimming.md>), [virtualisation](<https://devfeed.tech/tags/virtualisation.md>)

### AI overview

Contextual Memory Virtualisation (CMV) models an LLM session's accumulated state as a version-controlled directed acyclic graph, with snapshot, branch, and trim operations intended to support reuse across parallel sessions. Its three-pass trimming method preserves user messages and assistant responses verbatim while removing mechanical overhead such as raw tool outputs, base64 images, and metadata. In a single-user study of 76 coding sessions, trimming reduced tokens by a mean of 20%, reaching 86% in sessions with substantial overhead. Mixed tool-use sessions saw the largest average reduction, 39%, and reached break-even within 10 turns under prompt caching. These findings come from a single-user case study.

### Source excerpt

arXiv:2602.22402v2 Announce Type: replace-cross Abstract: As large language models engage in extended reasoning tasks, they accumulate significant state -- architectural mappings, trade-off decisions, codebase conventions -- within the context window. This understanding is lost when sessions reach context limits and undergo lossy compaction. We propose Contextual Memory Virtualisation (CMV), a system that treats accumulated LLM understanding as version-controlled state. Borrowing from operating system virtual memory, CMV models session history as a Directed Acyclic Graph (DAG) with formally defined snapshot, branch, and trim primitives that enable context reuse across independent parallel sessions. We introduce a three-pass structurally lossless trimming algorithm that preserves every user message and assistant response verbatim while reducing token counts by a mean of 20% and up to 86% for sessions with significant overhead by stripping mechanical bloat such as raw tool outputs, base64 images, and metadata. A single-user case-study evaluation across 76 real-world coding sessions demonstrates that trimming remains economically viable under prompt caching, with the strongest gains in mixed tool-use sessions, which average 39% reduction and reach break-even within 10 turns. A reference implementation is available at https://github.com/IngressionLabs/contextual-memory-virtualisation.

## Where Polanyi Meets Galois: Tacit Knowing as an Algebro-Deterministic Operation, Toward Re-rooting AI-Generated Science

DevFeed: [Where Polanyi Meets Galois: Tacit Knowing as an Algebro-Deterministic Operation, Toward Re-rooting AI-Generated Science](<https://devfeed.tech/articles/where-polanyi-meets-galois-tacit-knowing-as-an-algebro-deterministic-operation-toward-re-rooting-ai-generated-science-97991.md>)

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

Author: Hiroyuki Chuma, Kanji Otsuka, Yoichi Sato, Kodo Yamauchi

Published: 2026-10-23T04:00:00Z

Content type: opinion

Language: en

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

Topics: [Computer science](<https://devfeed.tech/topics/computer-science.md>), [knowledge-engineering](<https://devfeed.tech/topics/knowledge-engineering.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [audit](<https://devfeed.tech/tags/audit.md>), [confidence](<https://devfeed.tech/tags/confidence.md>), [craft](<https://devfeed.tech/tags/craft.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ne](<https://devfeed.tech/tags/cs-ne.md>), [dag](<https://devfeed.tech/tags/dag.md>), [generate](<https://devfeed.tech/tags/generate.md>), [knowledge](<https://devfeed.tech/tags/knowledge.md>), [llms](<https://devfeed.tech/tags/llms.md>), [memory](<https://devfeed.tech/tags/memory.md>), [mentor](<https://devfeed.tech/tags/mentor.md>), [science](<https://devfeed.tech/tags/science.md>), [student](<https://devfeed.tech/tags/student.md>), [tacit](<https://devfeed.tech/tags/tacit.md>), [trace](<https://devfeed.tech/tags/trace.md>), [transmission](<https://devfeed.tech/tags/transmission.md>), [valuation](<https://devfeed.tech/tags/valuation.md>)

### AI overview

The paper models tacit knowing as a memory's operating regime, using VaCoAl, an XOR-and-shift hyperdimensional memory over GF(2), implemented as CASRAM and PyVaCoAl. Its DAG offers two readings: Rescue repairs every collision for an exactly auditable trace but does not rank paths; Don't Care tolerates collisions and produces path confidence (CR₂), which favors direct routes. The authors use this audit-valuation tradeoff to distinguish query-revealed tacitness from regime-bound tacitness, which can be stated only after it is lost. For AI-generated science, they propose that LLMs generate results, VaCoAl/PyVaCoAl preserve traces and confidence, and people evaluate their value--a role they argue cannot be delegated. They characterize untraceable, checkable AI results as "rootless explicit knowledge" and frame their broader claims, including conviviality as a basis for evolvability, as conjectures or testable predictions.

### Source excerpt

arXiv:2610.16102v2 Announce Type: replace-cross Abstract: We argue that tacit knowing is better modelled as an operating regime of a memory than as a kind of content. Our substrate is VaCoAl, an algebro-deterministic XOR-and-shift hyperdimensional memory over GF(2), realized as CASRAM and PyVaCoAl. In it, a DAG reads two ways. Repairing every collision (Rescue) makes the trace exactly auditable but ranks no path higher; tolerating them (Don't Care) yields a path confidence, CR$_2$, silently favouring direct routes. This audit-valuation complementarity formalizes Polanyi's claim that tacit and explicit are not sharply divided. It separates contingent tacitness, which a new query brings out (AlphaGo's game tree), from regime-bound tacitness, statable only once it is gone (AlphaGo's hunches). (1) Polanyi's from-to structure reads as non-commutative binding. (2) Explicating the valuation destroys it, as with Polanyi's pianist, yet a closed-form law states it. Polanyi, Nonaka, Tsoukas and Collins each capture part of this, narrowly; even Nonaka and von Krogh's continuum cannot tell the classes apart. (3) Collins's three tacit knowledges become strata, one outside the substrate. (4) Our mentor-student DAG is a tacit-transmission graph. (5) Tao's remark that AI-solved problems spawn few follow-ups reveals rootless explicit knowledge: checkable results no one can trace or yet understands. To re-root them, LLMs generate, VaCoAl/PyVaCoAl keeps an auditable trace with its confidence, and people value, a role virtue epistemology shows cannot be offloaded. Art, craft and skill show the same decoupling of form from the maker's becoming. (6) On Mercier and Sperber's account an LLM is reason's arguing side set loose, a sophist; truth-seeking lies deeper, in Polanyi's conviviality, which we conjecture is the root of evolvability and, as the Buddhist idea that plants and lands attain buddhahood suggests, reaches beyond humans. Testable predictions follow.

## Generalizing Metropolis-Hastings for DAG Sampling

DevFeed: [Generalizing Metropolis-Hastings for DAG Sampling](<https://devfeed.tech/articles/generalizing-metropolis-hastings-for-dag-sampling-96919.md>)

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

Author: Daniele Nikzad, Mikko Koivisto

Published: 2026-10-23T04: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: [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [bayesian](<https://devfeed.tech/tags/bayesian.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [dag](<https://devfeed.tech/tags/dag.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [learning](<https://devfeed.tech/tags/learning.md>), [markov-chain-monte-carlo](<https://devfeed.tech/tags/markov-chain-monte-carlo.md>), [metropolis](<https://devfeed.tech/tags/metropolis.md>), [sampling](<https://devfeed.tech/tags/sampling.md>), [stat-co](<https://devfeed.tech/tags/stat-co.md>)

### AI overview

The paper introduces duet sampling, a Metropolis-Hastings generalization for DAG posterior sampling. Each iteration uses one proposal distribution to generate a candidate and another to evaluate the return to the current state in the acceptance criterion. Building on this, the authors propose moves that simultaneously resample parents for multiple DAG nodes. They report that these moves, individually and combined, outperform prior state-of-the-art methods using a more restrictive move pool, even when those methods also use duet sampling; the abstract says the added flexibility comes at no extra computational cost. The supplied text provides no experimental details or quantitative results.

### Source excerpt

arXiv:2610.30291v1 Announce Type: new Abstract: A fundamental challenge in Bayesian network structure learning lies in efficiently approximating the posterior distribution of directed acyclic graphs (DAGs). For large, high-dimensional datasets, the task remains beyond the capabilities of current methods. This work advances Markov chain Monte Carlo algorithms by introducing novel moves that simultaneously resample the parents for multiple nodes of the DAG. At the core of these moves is duet sampling, a new generalization of the Metropolis-Hastings algorithm that selects two proposal distributions from a pool at each iteration. One is used for generating a candidate state of the Markov chain and another for evaluating the return to the current state; both are ingredients of an appropriately crafted acceptance criterion. Pairing different proposal distributions provides additional freedom and enables constructing Markov chains that mix more efficiently than their basic Metropolis-Hastings counterparts, at no additional computational cost. Experiments show that our new moves, both individually and in combination, outperform the previous state of the art, which relies on a more restrictive pool of moves. This advantage persists even when letting the previous methods leverage duet sampling to enhance their performance.

## Seven Months with Swamp

DevFeed: [Seven Months with Swamp](<https://devfeed.tech/articles/seven-months-with-swamp-86868.md>)

Original publisher: [Read original article](<https://swamp-club.com/feed/p/ddde30aa-ed06-490f-b25d-62e1d7266fbb/go>)

Author: webframp

Published: 2026-10-14T18:45:54Z

Content type: opinion

Language: en

Sources: [Swamp Club Feed](<https://devfeed.tech/sources/swamp-club-feed.md>)

Topics: [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>), [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [aws](<https://devfeed.tech/tags/aws.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [cloudformation](<https://devfeed.tech/tags/cloudformation.md>), [compliance](<https://devfeed.tech/tags/compliance.md>), [compose](<https://devfeed.tech/tags/compose.md>), [config](<https://devfeed.tech/tags/config.md>), [dag](<https://devfeed.tech/tags/dag.md>), [data](<https://devfeed.tech/tags/data.md>), [datadog](<https://devfeed.tech/tags/datadog.md>), [datastores](<https://devfeed.tech/tags/datastores.md>), [detection](<https://devfeed.tech/tags/detection.md>), [devops](<https://devfeed.tech/tags/devops.md>), [dns](<https://devfeed.tech/tags/dns.md>), [dynamodb](<https://devfeed.tech/tags/dynamodb.md>), [ecs](<https://devfeed.tech/tags/ecs.md>), [eventbridge](<https://devfeed.tech/tags/eventbridge.md>), [extension](<https://devfeed.tech/tags/extension.md>), [extensions](<https://devfeed.tech/tags/extensions.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [skills](<https://devfeed.tech/tags/skills.md>), [swamp](<https://devfeed.tech/tags/swamp.md>)

### AI overview

The author's central finding is that reliable agent behavior came from putting procedures in code rather than relying on prompt-based skills. In Swamp, typed model methods run against live systems and record versioned data; workflows compose those methods into a DAG, so agents choose behaviors and inspect results while procedures remain repeatable, testable, and reviewable across model upgrades. A workflow that always pulled metrics fixed an outage investigation's missed cold-start spike. Separately written observers later supplied data for a drift detector that made no AWS API calls of its own, instead normalizing stored snapshots and diffing them against a baseline. The author reports publishing 165 extensions. Load testing reached 500 ECS Fargate workers and briefly overwhelmed telemetry ingestion; DynamoDB sync tuning exposed successive bottlenecks. These tests surfaced limits, while the author identifies shared use by more than a hundred engineers as an open scaling question.

### Source excerpt

I tried agents with skills. When they failed, I found swamp.

## Git date parsing and identity handling show limits in a legal-document archive

DevFeed: [Git date parsing and identity handling show limits in a legal-document archive](<https://devfeed.tech/articles/git-will-stop-working-in-2100-64957.md>)

Original publisher: [Read original article](<https://hackernoon.com/git-will-stop-working-in-2100?source=rss>)

Author: Maximiliano Morel

Published: 2026-10-05T15:16:25Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Git](<https://devfeed.tech/topics/git.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [ISO 8601](<https://devfeed.tech/topics/iso-8601.md>), [timezone](<https://devfeed.tech/topics/timezone.md>), [parallel workspaces](<https://devfeed.tech/topics/parallel-workspaces.md>)

Tags: [computing](<https://devfeed.tech/tags/computing.md>), [dag](<https://devfeed.tech/tags/dag.md>), [developers](<https://devfeed.tech/tags/developers.md>), [future](<https://devfeed.tech/tags/future.md>), [git](<https://devfeed.tech/tags/git.md>), [git-2099-date-limit](<https://devfeed.tech/tags/git-2099-date-limit.md>), [git-commit-backdating](<https://devfeed.tech/tags/git-commit-backdating.md>), [git-commit-metadata](<https://devfeed.tech/tags/git-commit-metadata.md>), [git-date-parsing](<https://devfeed.tech/tags/git-date-parsing.md>), [git-legal-history](<https://devfeed.tech/tags/git-legal-history.md>), [git-limitations](<https://devfeed.tech/tags/git-limitations.md>), [git-y2k](<https://devfeed.tech/tags/git-y2k.md>), [legal](<https://devfeed.tech/tags/legal.md>), [version-control](<https://devfeed.tech/tags/version-control.md>)

### AI overview

After importing more than 330,000 Chilean legal documents into Git, the author describes problems with historical and future commit dates, inconsistent date and identity parsing, and misleading errors. Direct timestamps can pass beyond 2099, while ordinary date parsing rejects some ranges. The author compares Git with Mercurial and Fossil, and describes keeping historical metadata separately alongside the documents.

### Source excerpt

I put 330,000+ Chilean legal documents into Git and discovered strange limits around historical dates, future timestamps, identities, and parsers.

[Next page](<https://devfeed.tech/tags/dag.md?cursor=WyIyMDI2LTEwLTA1VDE1OjE2OjI1KzAwOjAwIiwgIjQwZTAwODU2LWMzNGQtNDExMC1iMTNkLTM1OTRhY2JlYTkxMiJd>)