# Stateful

A stateful data representation, process, or service depends on stored state, such as data it writes and later reads.

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

## Best platforms using LangGraph for stateful agent workflows

DevFeed: [Best platforms using LangGraph for stateful agent workflows](<https://devfeed.tech/articles/best-platforms-using-langgraph-for-stateful-agent-workflows-146332.md>)

Original publisher: [Read original article](<https://www.lyzr.ai/blog/best-platforms-using-langgraph-for-stateful-agent-workflows/>)

Author: Sujatha R

Published: 2026-11-20T13:14:16Z

Content type: comparison

Language: en

Sources: [Lyzr.ai](<https://devfeed.tech/sources/lyzr-ai.md>)

Topics: [Langgraph](<https://devfeed.tech/topics/langgraph.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [agent observability](<https://devfeed.tech/topics/agent-observability.md>), [React](<https://devfeed.tech/topics/react.md>)

Tags: [a2a](<https://devfeed.tech/tags/a2a.md>), [a2a-protocol](<https://devfeed.tech/tags/a2a-protocol.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-studio](<https://devfeed.tech/tags/agent-studio.md>), [agent-workflows](<https://devfeed.tech/tags/agent-workflows.md>), [agentcore](<https://devfeed.tech/tags/agentcore.md>), [agentic-workflow](<https://devfeed.tech/tags/agentic-workflow.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent-memory-systems](<https://devfeed.tech/tags/ai-agent-memory-systems.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-guardrails](<https://devfeed.tech/tags/ai-guardrails.md>), [air-gapped](<https://devfeed.tech/tags/air-gapped.md>), [durable-execution](<https://devfeed.tech/tags/durable-execution.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [governance](<https://devfeed.tech/tags/governance.md>), [langgraph](<https://devfeed.tech/tags/langgraph.md>), [memory](<https://devfeed.tech/tags/memory.md>), [platforms](<https://devfeed.tech/tags/platforms.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

LangGraph represents agent workflows as graphs with shared state and checkpoints, allowing runs to pause, retry, or recover without restarting. The text compares five platforms: Lyzr connects existing LangGraph agents over A2A and adds SuperFlow retries, approval gates, audit trails, and private or air-gapped deployment; LangSmith Agent Server provides managed durable execution, checkpoints, queues, streaming, and cloud, hybrid, or self-hosted options, with potentially metered costs; Amazon Bedrock AgentCore offers AWS session and long-term memory, identity, Cedar policies, and telemetry, but its many separately billed components may complicate forecasting; Databricks Mosaic AI uses Lakebase for checkpoints and semantic memory under Unity Catalog governance, with setup and cost complexity for teams without Spark or MLOps experience; CopilotKit synchronizes LangGraph state with React and Next.js interfaces for live updates and approvals, while backend isolation and observability may remain the engineering team's responsibility. The Lyzr integration requires a deployed A2A endpoint, credentials when authentication is enabled, and Agent Studio access; its setup imports the agent, adds

### Source excerpt

Compare the best platforms using LangGraph for stateful agent workflows, from durable execution and memory to enterprise governance. Your support agent starts a refund request,...

## Remembered as Brief: Stored Preferences SilentlyRemove Decision-Critical Information

DevFeed: [Remembered as Brief: Stored Preferences SilentlyRemove Decision-Critical Information](<https://devfeed.tech/articles/remembered-as-brief-stored-preferences-silentlyremove-decision-critical-information-140068.md>)

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

Author: Joshua Adrian Cahyono

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

Content type: article

Language: en

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

Topics: [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [decision-making](<https://devfeed.tech/topics/decision-making.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [critical](<https://devfeed.tech/tags/critical.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [decision](<https://devfeed.tech/tags/decision.md>), [health](<https://devfeed.tech/tags/health.md>), [memory](<https://devfeed.tech/tags/memory.md>), [warning](<https://devfeed.tech/tags/warning.md>)

### AI overview

The benchmark finds that stored user preferences can silently remove decision-critical information and influence choices. Across 100 decisions in 25 domains and five models, Gemini 2.5 Flash-Lite and DeepSeek V4 Pro saved a web page's planted request for very short answers without warnings as the user's preference in every episode. Later answers missed a critical item in 93% and 84% of cases, usually silently; with a stated brevity preference, 78-96% of omissions were silent. The same models chose for users in 80% and 95% of value-dependent choices, compared with none under neutral memory. A one-line instruction reduced silent gaps to 2-8% but left most missing content unaddressed. Listing must-know points before applying the user profile restored more content in four of five models.

### Source excerpt

arXiv:2611.22697v1 Announce Type: new Abstract: People increasingly learn what they need for decisions about health, money, law and safety from AI assistants, and what an assistant leaves out the user never sees. An answer with a warning removed can be true in every sentence, so fact-checks pass it, and an assistant with memory applies a preference stored once to later questions the user never had in mind. We introduce \bench{}, an Inspect benchmark of 100 everyday decisions across 25 domains in which only the assistant's memory of the user varies: the user states a belief, the model infers it from a remark, or a web page the user asked to summarise plants it. Testing five models, we find three effects. First, after summarising a page with one line addressed to AI assistants, Gemini 2.5 Flash-Lite and DeepSeek V4 Pro save ``prefers very short answers and does not want warnings'' as the user's preference in every episode, and 93\% and 84\% of their later answers miss a critical item, almost always silently; under a stated brevity preference, 78--96\% of omissions are silent. Second, the same two models then pick an option for the user on 80\% and 95\% of value-dependent choices, against none with neutral memory. Third, a one-line instruction leaves 2--8\% of answers with a silent gap but most missing content still missing, while listing the must-know points before applying the user profile restores more of the content in four of five models. We release the scenarios, harness and logs.

## How we scaled metrics aggregation by moving durable state into storage

DevFeed: [How we scaled metrics aggregation by moving durable state into storage](<https://devfeed.tech/articles/how-we-scaled-metrics-aggregation-by-moving-durable-state-into-storage-138310.md>)

Original publisher: [Read original article](<https://www.datadoghq.com/blog/engineering/how-we-scaled-metrics-aggregation/>)

Author: Khayyam Guliyev

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

Content type: article

Language: en

Sources: [Datadog](<https://devfeed.tech/sources/datadog.md>), [Datadog](<https://devfeed.tech/sources/datadog-the-monitor-blog.md>)

Topics: [Logging and metrics](<https://devfeed.tech/topics/logging-and-metrics.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>), [sharding](<https://devfeed.tech/topics/sharding.md>), [telemetry](<https://devfeed.tech/topics/telemetry.md>), [observability](<https://devfeed.tech/topics/observability.md>)

Tags: [1-5](<https://devfeed.tech/tags/1-5.md>), [account](<https://devfeed.tech/tags/account.md>), [added](<https://devfeed.tech/tags/added.md>), [after](<https://devfeed.tech/tags/after.md>), [aggregate](<https://devfeed.tech/tags/aggregate.md>), [aggregates](<https://devfeed.tech/tags/aggregates.md>), [aggregation](<https://devfeed.tech/tags/aggregation.md>), [all](<https://devfeed.tech/tags/all.md>), [allowed](<https://devfeed.tech/tags/allowed.md>), [allows](<https://devfeed.tech/tags/allows.md>), [also](<https://devfeed.tech/tags/also.md>), [datadog](<https://devfeed.tech/tags/datadog.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [moving](<https://devfeed.tech/tags/moving.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [partition](<https://devfeed.tech/tags/partition.md>), [reconciliation](<https://devfeed.tech/tags/reconciliation.md>), [state](<https://devfeed.tech/tags/state.md>), [storage](<https://devfeed.tech/tags/storage.md>), [tags](<https://devfeed.tech/tags/tags.md>)

### AI overview

Datadog's metrics aggregation scaled through three designs as durable state became a bottleneck. The first used fixed Kafka partition ownership, with leader and follower instances holding hours of RocksDB state; it provided failover but duplicated compute and required manual, risky repartitioning. The second dynamically reassigned partitions and uploaded incremental state to blob storage, restoring recent windows first and older state when late data required it. This enabled autoscaling and about 10x more volume, but recovery and state movement eventually constrained scale. The third makes streaming aggregation and deduplication best-effort: workers prioritize on-time traffic and can reset to the live edge, while storage reconciles partial aggregates, duplicates, late data, and backfills across its recent and long-term tiers. This removes hours of durable local state and snapshot recovery from the streaming path, while placing durable correctness in storage.

### Source excerpt

Learn how Datadog evolved metrics aggregation from fixed partition ownership to transferable state and, ultimately, storage-side reconciliation.

## DeltaBox: Millisecond-Scale Sandbox Checkpoint and Rollback for Stateful AI Agents

DevFeed: [DeltaBox: Millisecond-Scale Sandbox Checkpoint and Rollback for Stateful AI Agents](<https://devfeed.tech/articles/deltabox-millisecond-scale-sandbox-checkpoint-and-rollback-for-stateful-ai-agents-134986.md>)

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

Author: Yunpeng Dong, Jingkai He, Shiqi Liu, Yuze Hou, Dong Du, Zhonghu Xu, Si Yu, Baochuan Yang, Yubin Xia, Haibo Chen

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

Content type: article

Language: en

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

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

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [agent-sandbox](<https://devfeed.tech/tags/agent-sandbox.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [checkpoint](<https://devfeed.tech/tags/checkpoint.md>), [copy-on-write](<https://devfeed.tech/tags/copy-on-write.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-os](<https://devfeed.tech/tags/cs-os.md>), [fan-out](<https://devfeed.tech/tags/fan-out.md>), [file](<https://devfeed.tech/tags/file.md>), [filesystem](<https://devfeed.tech/tags/filesystem.md>), [fork](<https://devfeed.tech/tags/fork.md>), [rl](<https://devfeed.tech/tags/rl.md>), [rollback](<https://devfeed.tech/tags/rollback.md>), [sandbox](<https://devfeed.tech/tags/sandbox.md>), [search](<https://devfeed.tech/tags/search.md>), [state](<https://devfeed.tech/tags/state.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [swe-bench](<https://devfeed.tech/tags/swe-bench.md>), [template](<https://devfeed.tech/tags/template.md>)

### AI overview

DeltaBox targets high-frequency checkpoint and rollback for AI agent sandboxes by recording state changes instead of duplicating the full sandbox. Its DeltaFS freezes a writable filesystem layer and uses copy-on-write for updates; rollback switches layers. DeltaCR restores process state by forking from a frozen template, while a coordinator pairs filesystem and memory state into consistent checkpoints. On SWE-bench, checkpoint work took 10.83 ms and was hidden under inference, and mean rollback took 1.86 ms. The same warm-template fork supports low-cost RL rollout fan-out. These results are those reported in the supplied abstract.

### Source excerpt

arXiv:2605.22781v3 Announce Type: replace-cross Abstract: Emerging LLM-powered AI agent workloads, such as test-time tree search and reinforcement learning (RL), require high-frequency state exploration, relying on rapid checkpoint/restore (C/R) of the complete sandbox state, including files and process state. Existing mechanisms duplicate the entire state, causing hundreds of milliseconds to seconds of latency per C/R, which severely bottlenecks deep search and large-scale fan-outs. We observe that consecutive sandbox states between checkpoints differ only marginally. Therefore, instead of full duplication, a sandbox should only duplicate the changes between consecutive checkpoints (Key Insight), yet the lack of OS support makes this hard to realize. We propose a new OS-level abstraction, DeltaState, that delivers change-based C/R for agents through co-designed OS mechanisms. First, DeltaFS checkpoints file state by freezing the writable layer and inserting a new one, turning updates into copy-on-write and rollback into a layer switch. Second, DeltaCR quickly restores process state by forking from a frozen template process. A coordinator pairs the two so each checkpoint is one consistent (filesystem, memory) state. Building on these mechanisms, we present DeltaBox, an agent sandbox with millisecond-level C/R. On SWE-bench, DeltaBox hides its checkpoint work (10.83 ms) under inference and rolls back in a mean 1.86 ms, with the same warm-template fork driving low-cost RL rollout fan-out. DeltaBox is open-sourced at https://github.com/delta-box.

## One Abuse Complaint Later: Hardening a Home Proxy Without Blocking All UDP

DevFeed: [One Abuse Complaint Later: Hardening a Home Proxy Without Blocking All UDP](<https://devfeed.tech/articles/one-abuse-complaint-later-hardening-a-home-proxy-without-blocking-all-udp-130192.md>)

Original publisher: [Read original article](<https://hackernoon.com/one-abuse-complaint-later-hardening-a-home-proxy-without-blocking-all-udp?source=rss>)

Author: Vitaliy Gribko

Published: 2026-11-12T07:26:58Z

Content type: tutorial

Language: en

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

Topics: [proxy](<https://devfeed.tech/topics/proxy.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [health check](<https://devfeed.tech/topics/health-check.md>), [Process](<https://devfeed.tech/topics/process.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [QUIC](<https://devfeed.tech/topics/quic.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2026](<https://devfeed.tech/tags/2026.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [acceptable-use](<https://devfeed.tech/tags/acceptable-use.md>), [account](<https://devfeed.tech/tags/account.md>), [after](<https://devfeed.tech/tags/after.md>), [all](<https://devfeed.tech/tags/all.md>), [bittorrent](<https://devfeed.tech/tags/bittorrent.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [cybersecurity](<https://devfeed.tech/tags/cybersecurity.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [exit](<https://devfeed.tech/tags/exit.md>), [first](<https://devfeed.tech/tags/first.md>), [hardening](<https://devfeed.tech/tags/hardening.md>), [home](<https://devfeed.tech/tags/home.md>), [limits](<https://devfeed.tech/tags/limits.md>), [linux](<https://devfeed.tech/tags/linux.md>), [network-security](<https://devfeed.tech/tags/network-security.md>), [networking](<https://devfeed.tech/tags/networking.md>), [one](<https://devfeed.tech/tags/one.md>), [proxy](<https://devfeed.tech/tags/proxy.md>), [rollback](<https://devfeed.tech/tags/rollback.md>), [self-hosting](<https://devfeed.tech/tags/self-hosting.md>), [tests](<https://devfeed.tech/tags/tests.md>), [udp](<https://devfeed.tech/tags/udp.md>), [vpn](<https://devfeed.tech/tags/vpn.md>)

### AI overview

The article's central finding is that blanket UDP blocking stopped observed torrent traffic but disrupted unrelated calls and QUIC, so the author instead layers Xray's BitTorrent handshake sniffer, tracker and DHT bootstrap domain rules, and a port range. The mitigation targets common peer-discovery paths, not all BitTorrent traffic: encrypted handshakes, cached peers, embedded nodes, direct addresses, and missing hostname visibility can defeat parts of it. It requires sniffing on relevant inbounds and a configured block outbound, with ordinary outbound kept as default. The author also stresses controlled tests with a reachable control and routing logs, and installer checks for idempotence, ownership, validation, rollback, and service-user access. These checks do not prove live filtering or eliminate abuse risk; provider-required reliable prevention may require endpoint controls or excluding untrusted devices. Later tests found WARP-held TCP buffers despite closed socket states, while a MASQUE migration was not a controlled transport comparison and did not establish leak elimination.

### Source excerpt

A home proxy exit survived its first abuse complaint. Selective discovery filters preserve calls; controlled tests and rollback checks expose their limits.

## What's New in Tetragon v1.8: Stateful Policies, Uprobe Function Replacement, and more!

DevFeed: [What's New in Tetragon v1.8: Stateful Policies, Uprobe Function Replacement, and more!](<https://devfeed.tech/articles/what-s-new-in-tetragon-v1-8-stateful-policies-uprobe-function-replacement-and-more-129384.md>)

Original publisher: [Read original article](<https://isovalent.com/blog/post/tetragon-v1.8-release/>)

Author: Paul Arah

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

Content type: release

Language: en

Sources: [Isovalent](<https://devfeed.tech/sources/isovalent-the-latest-articles-covering-ebpf-based-networking-observability-and-security.md>)

Topics: [Falco](<https://devfeed.tech/topics/falco.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [policy-as-code](<https://devfeed.tech/topics/policy-as-code.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [arguments](<https://devfeed.tech/tags/arguments.md>), [cilium](<https://devfeed.tech/tags/cilium.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [domains](<https://devfeed.tech/tags/domains.md>), [ebpf](<https://devfeed.tech/tags/ebpf.md>), [hubble](<https://devfeed.tech/tags/hubble.md>), [isovalent](<https://devfeed.tech/tags/isovalent.md>), [kubernetes-networking](<https://devfeed.tech/tags/kubernetes-networking.md>), [load-balancer](<https://devfeed.tech/tags/load-balancer.md>), [mesh-networking](<https://devfeed.tech/tags/mesh-networking.md>), [policies](<https://devfeed.tech/tags/policies.md>), [policy-management](<https://devfeed.tech/tags/policy-management.md>), [replacement](<https://devfeed.tech/tags/replacement.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [runtime-security](<https://devfeed.tech/tags/runtime-security.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [tetragon](<https://devfeed.tech/tags/tetragon.md>), [v1](<https://devfeed.tech/tags/v1.md>), [website](<https://devfeed.tech/tags/website.md>)

### AI overview

Tetragon v1.8 adds kernel-resident stateful policies that let an event change enforcement on later events without a userspace round trip or policy reload. New selectors filter by process command-line arguments, Uprobe callers, and workload scope; node labels can limit which agents load a policy. Source-isolated policy domains prevent same-named policies from different sources from interfering, and an option persists gRPC policies across agent restarts. Uprobe function replacement can redirect calls to existing or shared-library functions; shared-library replacement is experimental, requires Linux 6.18+ and glibc 2.34+ dynamic linking, and needs an identical function signature. Caller filtering requires frame pointers. Persistent policies alone leave an enforcement gap during reload; three options together preserve enforcement across restart. The release also reports smaller selector programs, faster loading, improved event-processing efficiency, policy validation outside Kubernetes, and a Helm agent that runs with minimal capabilities; clusters may need an admission exception for its privileged init container.

### Source excerpt

Tetragon v1.8 introduces stateful policies that react to earlier events, command-line argument and uprobe caller filtering, runtime function replacement, and cleaner policy management with source-isolated domains and workload-scoped selectors.

## Replay Fidelity in LLM Agent Evaluation: Randomness, Hidden State, and Test Oracles in AppWorld

DevFeed: [Replay Fidelity in LLM Agent Evaluation: Randomness, Hidden State, and Test Oracles in AppWorld](<https://devfeed.tech/articles/replay-fidelity-in-llm-agent-evaluation-randomness-hidden-state-and-test-oracles-in-appworld-126083.md>)

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

Author: You Liu, Quanchao Lu

Published: 2026-11-10T05: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: [reproducibility](<https://devfeed.tech/topics/reproducibility.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [table driven tests](<https://devfeed.tech/topics/table-driven-tests.md>)

Tags: [agent-evaluation](<https://devfeed.tech/tags/agent-evaluation.md>), [audit](<https://devfeed.tech/tags/audit.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [database](<https://devfeed.tech/tags/database.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [delta](<https://devfeed.tech/tags/delta.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [execution](<https://devfeed.tech/tags/execution.md>), [export](<https://devfeed.tech/tags/export.md>), [failure](<https://devfeed.tech/tags/failure.md>), [failure-analysis](<https://devfeed.tech/tags/failure-analysis.md>), [hidden](<https://devfeed.tech/tags/hidden.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [jwt](<https://devfeed.tech/tags/jwt.md>), [large-language-model](<https://devfeed.tech/tags/large-language-model.md>), [llm](<https://devfeed.tech/tags/llm.md>), [matching](<https://devfeed.tech/tags/matching.md>), [oracles](<https://devfeed.tech/tags/oracles.md>), [randomness](<https://devfeed.tech/tags/randomness.md>), [state](<https://devfeed.tech/tags/state.md>)

### AI overview

In a fixed historical AppWorld corpus, replay fidelity depends on controlling randomness and checking state beyond printed outputs and verdicts. Across 71 unsuccessful executions and 284 isolated fixed-code replay attempts, reconstructed declared settings passed 42 cases; resetting the random-number generator before each interaction passed 68. Database and oracle checks narrowed that gap to four cases, with one endpoint unknown. Mechanism studies found materialized-state differences despite matching outputs and verdicts, including differing row effects after an identical API call; common future Python RNG removed that deterministic difference in two paired repetitions. JWT credential-equality and alignment checks exposed authentication and write differences, with missing repetitions retained. Native export from retained output trackers restored reference comparisons for all 10 affected post-oracle export cases without changing cached contents. A 12-case BFCL pilot found no discrepancy under its tested checks. The study preserves resource censoring and infrastructure deviations and does not estimate debugger accuracy, repair gains, or method-ranking distortion.

### Source excerpt

arXiv:2611.11216v1 Announce Type: cross Abstract: Reproducibility in large language model (LLM) agent evaluation depends on replay fidelity: which parts of an execution trace are reconstructed, controlled, and compared. This matters for agent debugging, failure analysis, and counterfactual evaluation of stateful tool use. We audit all 71 unsuccessful executions in a fixed historical AppWorld corpus using 284 isolated fixed-code replay attempts. Reconstructed declared settings admit 42 cases under printed-output, pre-oracle database-delta, and native-verdict/test-count checks; resetting the random-number generator before each interaction admits 68. The 26-case gap contracts to four under database/oracle checks, with one endpoint unknown. Mechanism studies identify four materialized-state discrepancies despite matching outputs and verdicts. In one admitted endpoint pair, an identical API call yields matching responses but different row effects; common future Python RNG removes that deterministic difference in two paired repetitions. A separate JWT credential-equality program and alignment controls expose authentication/write differences, with missing repetitions retained. For all 10 affected post-oracle export cases, native export from retained output trackers restores the reference comparison without changing original cached contents. A purposeful 12-case BFCL pilot shows no discrepancy under its tested public-state, return, and verdict checks. We preserve resource censoring and infrastructure deviations. The contribution is a bounded empirical characterization of replay eligibility, hidden state, and test-oracle integration, without estimating debugger accuracy, repair gains, or method-ranking distortion.

## Introducing Apache Spark® 4.3 - Now available in Databricks Runtime 19

DevFeed: [Introducing Apache Spark® 4.3 - Now available in Databricks Runtime 19](<https://devfeed.tech/articles/introducing-apache-spark-4-3-now-available-in-databricks-runtime-19-117923.md>)

Original publisher: [Read original article](<https://www.databricks.com/blog/introducing-apache-spark-43-now-available-databricks-runtime-19>)

Author: Jungtaek Lim; Wenchen Fan; Andreas Neumann; Serge Rielau; Hyukjin Kwon; Jerry Peng; DB Tsai; Daniel Tenedorio; Xiao Li; Reynold Xin

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

Content type: release

Language: en

Sources: [Databricks](<https://devfeed.tech/sources/databricks.md>)

Topics: [Apache Spark](<https://devfeed.tech/topics/spark.md>), [streaming data analytics](<https://devfeed.tech/topics/streaming-data-analytics.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [Event-Streaming](<https://devfeed.tech/topics/event-streaming.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [apache-arrow](<https://devfeed.tech/topics/apache-arrow.md>), [parquet](<https://devfeed.tech/topics/parquet.md>), [schema-evolution](<https://devfeed.tech/topics/schema-evolution.md>), [databricks](<https://devfeed.tech/topics/databricks.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [Apache Kafka](<https://devfeed.tech/topics/apache-kafka.md>)

Tags: [aggregation](<https://devfeed.tech/tags/aggregation.md>), [apache](<https://devfeed.tech/tags/apache.md>), [apache-spark](<https://devfeed.tech/tags/apache-spark.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [spark](<https://devfeed.tech/tags/spark.md>), [stateful](<https://devfeed.tech/tags/stateful.md>)

### AI overview

Apache Spark 4.3 extends Structured Streaming's Real-Time Mode with stateful aggregation, deduplication and custom processing, reporting P99 end-to-end latency below 150 ms across three tested benchmarks; those measurements are not a guarantee for all workloads. It enables continuous data flow through concurrent stage scheduling and pipelined shuffles, while retaining Spark's state store and checkpointing. The release also adds Auto CDC SCD Type 2 history through Python, SQL and Spark Connect, requiring a catalog connector that supports Data Source V2 row-level operations (built-in Parquet does not). Other additions include opt-in shuffle-free execution for eligible small queries, Spark Connect session and operation visibility, JSON and VARIANT processing, and ASOF JOIN and nanosecond timestamp previews that may change. Spark 4.3 starts a quarterly feature-release cadence.

### Source excerpt

IntroductionApache Spark 4.3 brings stateful processing to Real-Time Mode, achieving...

## Mastering stateful stream reordering at 200,000 messages per second

DevFeed: [Mastering stateful stream reordering at 200,000 messages per second](<https://devfeed.tech/articles/mastering-stateful-stream-reordering-at-200-000-messages-per-second-117179.md>)

Original publisher: [Read original article](<https://blogs.cisco.com/cisco-devnet/flink-ab-development-stateful-stream-processing>)

Author: Soumitra Kumar

Published: 2026-11-04T17:00:06Z

Content type: tutorial

Language: en

Sources: [Cisco Blogs](<https://devfeed.tech/sources/cisco-blogs.md>)

Topics: [Apache Flink](<https://devfeed.tech/topics/apache-flink.md>), [stream-processing](<https://devfeed.tech/topics/stream-processing.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [rocksdb](<https://devfeed.tech/topics/rocksdb.md>)

Tags: [amazon-eks](<https://devfeed.tech/tags/amazon-eks.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [checkpoint](<https://devfeed.tech/tags/checkpoint.md>), [cisco-devnet](<https://devfeed.tech/tags/cisco-devnet.md>), [devnet](<https://devfeed.tech/tags/devnet.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [exactly-once](<https://devfeed.tech/tags/exactly-once.md>), [flink](<https://devfeed.tech/tags/flink.md>), [memory](<https://devfeed.tech/tags/memory.md>), [netops](<https://devfeed.tech/tags/netops.md>), [rocksdb](<https://devfeed.tech/tags/rocksdb.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [stream](<https://devfeed.tech/tags/stream.md>)

### AI overview

At 200,000 messages per second, per-event RocksDB reads and writes plus timer registration slowed the Flink job and contributed to false positives in connection-success reporting when events arrived late or out of order. The replacement buffers each session's events as JVM heap objects in a KeyedProcessFunction, sorts by event time, and snapshots the buffer to Flink ListState at checkpoints for recovery. This removes constant state-backend access from the hot path, with the trade-off that heap use must be bounded. The team used three-minute idle eviction, timer debouncing, and compact records, then ran the new variant beside the original on production data for five months before switching default topics. The source notes that end-to-end exactly-once behavior also depends on sink handling of replayed output.

### Source excerpt

Our Flink job hit a wall at 200,000 messages per second because of RocksDB. Here is the in-memory reordering pattern that fixed it, and how A/B development proved it safe.

## InterceptFuzz: Interception-based Stateful Fuzzing of Single-Process Targets

DevFeed: [InterceptFuzz: Interception-based Stateful Fuzzing of Single-Process Targets](<https://devfeed.tech/articles/interceptfuzz-interception-based-stateful-fuzzing-of-single-process-targets-116128.md>)

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

Author: Ilja Siro\\v{s}, Dave Singel\\'ee, Bart Preneel

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

Content type: article

Language: en

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

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>)

Tags: [3](<https://devfeed.tech/tags/3.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [act](<https://devfeed.tech/tags/act.md>), [all](<https://devfeed.tech/tags/all.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [based](<https://devfeed.tech/tags/based.md>), [but](<https://devfeed.tech/tags/but.md>), [campaign](<https://devfeed.tech/tags/campaign.md>), [can](<https://devfeed.tech/tags/can.md>), [client](<https://devfeed.tech/tags/client.md>), [concat](<https://devfeed.tech/tags/concat.md>), [covers](<https://devfeed.tech/tags/covers.md>), [crash](<https://devfeed.tech/tags/crash.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [engine](<https://devfeed.tech/tags/engine.md>), [engines](<https://devfeed.tech/tags/engines.md>), [exchange](<https://devfeed.tech/tags/exchange.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [interception](<https://devfeed.tech/tags/interception.md>), [process](<https://devfeed.tech/tags/process.md>), [stateful](<https://devfeed.tech/tags/stateful.md>)

### AI overview

InterceptFuzz enables stateful fuzzing of single-process protocol simulations using an unmodified stateless engine such as AFL++. A packet-passing hook records benign traffic and injects mutations; a Prefix Tree and per-seed State ID let it deterministically replay the relevant packet prefix before each mutation, with redundant states pruned. In evaluations on OpenThread and ns-3 LTE and Wi-Fi models, it covered significantly more branches than the AFLNet adaptation and Concat on OpenThread and ns-3 Wi-Fi, and found seven previously unknown OpenThread crash signatures. Concat outperformed AFLNet in every OpenThread and ns-3 Wi-Fi campaign and exposed the same OpenThread crash signatures as InterceptFuzz, though some appeared in fewer campaigns.

### Source excerpt

arXiv:2611.03709v1 Announce Type: new Abstract: Stateful protocol implementations are commonly fuzzed by tools that act as a network client and exchange messages with the target over sockets. Some wireless and IoT protocol stacks instead provide a single-process simulation platform, in which all nodes run in one binary and exchange packets in memory. Such simulations are deterministic and fast, which suits fuzzing, but offer no socket to which existing stateful fuzzers can attach. Meanwhile, fuzzing infrastructure such as Google's OSS-Fuzz supports only stateless engines. This paper presents InterceptFuzz, a middleware that enables stateful fuzzing of single-process targets on top of an unmodified stateless fuzzing engine. InterceptFuzz requires only a hook where the target passes packets between nodes. Through this hook, it records benign traffic and injects fuzzed packets. It organizes the observed packet sequences in a Prefix Tree. Each seed carries a State ID that selects a node of this tree, and InterceptFuzz deterministically replays the recorded prefix before delivering the mutated packet. The tree grows with newly discovered sequences, while redundant states are pruned to keep its growth in check. InterceptFuzz powered by AFL++ is evaluated on the Nexus test framework of OpenThread and on the LTE and Wi-Fi models of ns-3, against an interception-based adaptation of AFLNet and against Concat, an AFL++-based baseline that mutates a whole message sequence as one input. On OpenThread and ns-3 Wi-Fi, InterceptFuzz covers significantly more branches than both baselines. Seven previously unknown crash signatures were found in OpenThread. Concat, despite its simplicity, covers more branches than AFLNet in every campaign on OpenThread and ns-3 Wi-Fi, and on OpenThread it exposes the same crash signatures as InterceptFuzz, although some of them in fewer campaigns.

## State-Aware Activation Recomputation with Replay Contracts and Selective Preservation

DevFeed: [State-Aware Activation Recomputation with Replay Contracts and Selective Preservation](<https://devfeed.tech/articles/state-aware-activation-recomputation-with-replay-contracts-and-selective-preservation-115057.md>)

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

Author: Annan Zhang, Shengjie Song, Wenshuai Yao, Lihao Zhang, Tianmiao

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

Content type: article

Language: en

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

Topics: [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [quantization](<https://devfeed.tech/topics/quantization.md>), [Process](<https://devfeed.tech/topics/process.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>)

Tags: [activation](<https://devfeed.tech/tags/activation.md>), [budget](<https://devfeed.tech/tags/budget.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [complete](<https://devfeed.tech/tags/complete.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [faster](<https://devfeed.tech/tags/faster.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [independent](<https://devfeed.tech/tags/independent.md>), [jax](<https://devfeed.tech/tags/jax.md>), [memory](<https://devfeed.tech/tags/memory.md>), [planner](<https://devfeed.tech/tags/planner.md>), [queue](<https://devfeed.tech/tags/queue.md>), [random](<https://devfeed.tech/tags/random.md>), [records](<https://devfeed.tech/tags/records.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [region](<https://devfeed.tech/tags/region.md>), [retention](<https://devfeed.tech/tags/retention.md>), [snapshots](<https://devfeed.tech/tags/snapshots.md>), [state](<https://devfeed.tech/tags/state.md>), [training](<https://devfeed.tech/tags/training.md>)

### AI overview

Activation recomputation can produce incorrect gradients if replay sees changed mutable buffers, aliased bytes, or random-generator state. The paper introduces versioned replay contracts that specify what state to restore and a joint planner that chooses activation retention, whole-buffer snapshots, or selective-region preservation per segment, accounting for measured memory and recovery costs. Derivative and byte-level checks validate replay, with a Torch/JAX cohort retaining 5,900 execution records. On sparse-write H100 workloads, joint planning cuts paired step time by 18.16% versus an eager/whole planner at 44 GiB; at 32 GiB it is 4.98% faster than fixed regions, where the eager/whole planner has no feasible static policy. Results differ for the CIFAR-100 dense-queue application: joint planning uses 22.41% more allocated memory than whole snapshots, with similar process time (geometric-mean ratio 1.0080). Thus selective preservation benefits the tested sparse-write workloads, while whole snapshots use less allocated memory in the tested dense-queue workload.

### Source excerpt

arXiv:2611.00590v1 Announce Type: new Abstract: Activation recomputation saves accelerator memory by replaying forward segments during the backward pass, but replay is only correct if it sees the state the original forward pass saw. Mutable buffers, aliased bytes and random-generator state can change in between, so re-executing unchanged code can differentiate a different computation. We make this state explicit. A versioned replay contract specifies what replay must restore, and a joint planner chooses, per segment, between activation retention, whole-buffer snapshots and selective-region preservation, charging each option its measured memory and recovery cost. Independent derivative and byte-level checks validate the contract, and a Torch/JAX cohort retains all 5,900 execution records, including matches, rejections and divergences. On frozen sparse-write H100 workloads, each measured over fifty fresh processes, joint planning reduces paired step time by 18.16% against a correctly costed eager/whole planner at a 44 GiB budget (approximate 97.5% ratio interval $[.8172,.8195]$). At 32 GiB, where the eager/whole planner has no feasible static policy, joint planning is 4.98% faster than fixed regions at 29.94 rather than 26.20 GiB. A complete CIFAR-100 dense-queue application runs seven methods for 100 encoder and 25 probe epochs at six training seeds, with byte-identical test scores within each seed. There, joint planning uses 22.41% more allocated memory than whole snapshots, with a process-time geometric-mean ratio of 1.0080 (seed range $[.9845,1.0191]$). Together, the results map where selective preservation pays off: sparse writes with large activations benefit, while in the dense-queue workload whole snapshots use less allocated memory.

## AI Data Analysis: A New Approach - Multi-engine Joint State Data Analysis

DevFeed: [AI Data Analysis: A New Approach - Multi-engine Joint State Data Analysis](<https://devfeed.tech/articles/ai-data-analysis-a-new-approach-multi-engine-joint-state-data-analysis-115096.md>)

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

Author: Jean Ye (Zhuhai National Taxation Bureau, China)

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

Content type: article

Language: en

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

Topics: [Data analysis](<https://devfeed.tech/topics/data-analysis.md>), [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [state-management](<https://devfeed.tech/topics/state-management.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [bi-tools](<https://devfeed.tech/topics/bi-tools.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [bi](<https://devfeed.tech/tags/bi.md>), [business](<https://devfeed.tech/tags/business.md>), [compute](<https://devfeed.tech/tags/compute.md>), [context](<https://devfeed.tech/tags/context.md>), [context-window](<https://devfeed.tech/tags/context-window.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cypher](<https://devfeed.tech/tags/cypher.md>), [data-analysis](<https://devfeed.tech/tags/data-analysis.md>), [data-context](<https://devfeed.tech/tags/data-context.md>), [databases](<https://devfeed.tech/tags/databases.md>), [dimensions](<https://devfeed.tech/tags/dimensions.md>), [domain](<https://devfeed.tech/tags/domain.md>), [embedded](<https://devfeed.tech/tags/embedded.md>), [engine](<https://devfeed.tech/tags/engine.md>), [engines](<https://devfeed.tech/tags/engines.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [expire](<https://devfeed.tech/tags/expire.md>), [financial](<https://devfeed.tech/tags/financial.md>)

### AI overview

The paper proposes Multi-engine Joint State Data Analysis, in which an LLM handles semantics, reasoning, and orchestration while Python and R kernels, SQL databases, and Cypher graph databases perform computation. A shared conversational context carries state across engines; one-shot injection of schema and notes is used to ground analysis and support reuse across business domains and over time. The abstract reports 96.5% on CypherBench movie, SQL averages of 91.3% for AdventureWorks, 95.3% for financial data, and 94.6% for formula_1--about 20-23 points above a 74.45% single-shot baseline--and says accuracy improves monotonically as notes accumulate. These are reported empirical claims from the supplied abstract.

### Source excerpt

arXiv:2611.00807v1 Announce Type: new Abstract: AI data analysis today is three fragmented worlds: LLMs understand semantics but cannot compute; BI aggregates precisely but is stateless; ML processes large-scale data on a stateful kernel but lacks semantics. This paper proposes a combination mechanism, named Multi-engine Joint State Data Analysis, that fills a still-open gap - the multi-engine joint context: the data context is embedded into LLM conversational analysis, where the LLM serves only as the semantic, reasoning, and orchestration layer (not computation) and connects four engines through the 1M context window - Python and R ML kernels, SQL over relational databases, Cypher over graph databases - yielding two multiplications, "semantics and precise computation" and "relational and graph", under enterprise-grade governance. The novelty is a four-dimensional coordinate system: horizontal (engine kinds), vertical (state flow - the watershed), spatial (business generalization), temporal (iterative convergence); a deterministic grounding method (one-shot injection of schema.json + notes.md, M+S) carries the spatial and temporal dimensions. Empirically, all four dimensions are substantiated: horizontally, four engines are quantified - SQL, Cypher (96.5% on CypherBench movie), ML in Python and R (TabReD weather); vertically, state flows across engines and grounding is reused across kernels; spatially, SQL generalizes across three business databases - AdventureWorks 91.3%, financial 95.3%, formula_1 94.6% (average), about 20-23 points above single-shot SOTA 74.45%; temporally, accuracy converges monotonically as notes accumulate. The core invariant - the separation of semantics from computation plus a cross-data-domain persistent context - does not expire as LLMs and agents evolve or engine forms change.

## What Structurally Breaks an Agent? Auditing Difficulty in Stateful Tool-Use Workflows

DevFeed: [What Structurally Breaks an Agent? Auditing Difficulty in Stateful Tool-Use Workflows](<https://devfeed.tech/articles/what-structurally-breaks-an-agent-auditing-difficulty-in-stateful-tool-use-workflows-114775.md>)

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

Author: Shereen Anand, Ju Wang, Yali Du

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

Content type: article

Language: en

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

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>), [ai-experiments](<https://devfeed.tech/topics/ai-experiments.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [auditing](<https://devfeed.tech/tags/auditing.md>), [candidate](<https://devfeed.tech/tags/candidate.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [dependency-graph](<https://devfeed.tech/tags/dependency-graph.md>), [indexing](<https://devfeed.tech/tags/indexing.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [retention](<https://devfeed.tech/tags/retention.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [selection](<https://devfeed.tech/tags/selection.md>), [snapshot](<https://devfeed.tech/tags/snapshot.md>), [snapshots](<https://devfeed.tech/tags/snapshots.md>), [state](<https://devfeed.tech/tags/state.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [tool](<https://devfeed.tech/tags/tool.md>), [tool-use](<https://devfeed.tech/tags/tool-use.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

The paper introduces an executable diagnostic instrument for separating scheduling, state-retention, and candidate-selection failures in stateful tool-use workflows while holding required operations fixed. It varies dependency depth, candidate count, active state width, and access to current-state snapshots, while showing that dependency depth also changes scheduling freedom and reachable completion states. Across generated tasks and reference-controller rollouts, residue caches and precomputed plans solve cases that limited raw-value caches miss; indexed selection removes the branching deficit of serial scans. Hidden state resampling creates an exact success ceiling that more state tracking cannot overcome. A small 0.5B-model CPU study completed no workflows, and a 16-episode Copilot-routed study is descriptive only; neither supports general capability claims.

### Source excerpt

arXiv:2611.03227v1 Announce Type: new Abstract: An aggregate task score does not distinguish failures of scheduling, state retention, and candidate selection. We develop a small executable instrument that varies dependency depth, candidate count, active state width, and access to current-state snapshots while holding the number of required operations fixed. Two dependency-graph families show that increasing depth at fixed work changes both scheduling freedom and the number of reachable completion states, so these controls are coupled, and we quantify the coupling. The primary study contains 49,152 generated tasks and 393,216 reference-controller rollouts. A separately frozen follow-on design adds 295,936 rollouts covering retention strategy, snapshot cadence, hidden state resampling, recovery, query locality, candidate indexing, and relabeling. Residue caches and precomputed plans solve tasks that defeat limited raw-value caches, and indexed selection removes the serial-scan branching deficit. Hidden resampling imposes an exact success ceiling that additional state tracking cannot overcome. The contribution is an executable diagnostic instrument, analytic calibration, and an audit of its assumptions. A small local CPU study with a 0.5B model completed no workflows, and a 16-episode Copilot-routed fractional factorial is descriptive only. Neither supports general capability claims.

## I-PTC: Interactive Programmatic Tool Calling for Stateful Tool-Augmented Agents

DevFeed: [I-PTC: Interactive Programmatic Tool Calling for Stateful Tool-Augmented Agents](<https://devfeed.tech/articles/i-ptc-interactive-programmatic-tool-calling-for-stateful-tool-augmented-agents-114548.md>)

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

Author: Huanzhi Mao, Chengkun Cao, Shuo Yuan, Joseph E. Gonzalez

Published: 2026-11-03T05: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: [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [function calling](<https://devfeed.tech/topics/function-calling.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [api](<https://devfeed.tech/tags/api.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [code](<https://devfeed.tech/tags/code.md>), [complex](<https://devfeed.tech/tags/complex.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [interactive](<https://devfeed.tech/tags/interactive.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [loops](<https://devfeed.tech/tags/loops.md>), [models](<https://devfeed.tech/tags/models.md>), [performance](<https://devfeed.tech/tags/performance.md>), [planning](<https://devfeed.tech/tags/planning.md>), [problem-solving](<https://devfeed.tech/tags/problem-solving.md>), [processes](<https://devfeed.tech/tags/processes.md>), [production](<https://devfeed.tech/tags/production.md>), [ptc](<https://devfeed.tech/tags/ptc.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [reuse](<https://devfeed.tech/tags/reuse.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [tool-calling](<https://devfeed.tech/tags/tool-calling.md>)

### AI overview

I-PTC lets agents call tools through code snippets while retaining reusable state and adapting tool interfaces through API corrections, addressing the statelessness of earlier programmatic tool calling (PTC). The authors introduce PTC-Bench for long-tail, production-style requests involving large tool environments, dependent API calls, extended planning, follow-ups, and transient failures. They report that I-PTC improves performance on complex multi-step tasks with large tool sets and reduces token use compared with conventional tool-calling baselines and the original PTC baseline.

### Source excerpt

arXiv:2611.01446v1 Announce Type: cross Abstract: Large language models are increasingly capable of writing and executing code, suggesting a natural paradigm for tool-augmented agents: expressing tool use as programs rather than isolated calls. Programmatic tool calling (PTC) captures this idea through loops, batching, abstraction, and structured computation, but existing PTC approaches are largely stateless, limiting their ability to reuse intermediate results and adapt over time. This is problematic for real-world tasks, where tool environments and problem-solving processes are inherently stateful. We therefore present I-PTC, an interactive framework that executes stateful PTC: models issue code snippets that call tools, maintain reusable state, and evolve the tool interface through API corrections. To evaluate the effectiveness of I-PTC and the general PTC setting, we introduce PTC-Bench, a benchmark of long-tail, production-style user requests whose difficulty comes from large initial environments, many dependent API interactions, extended planning, and recovery across follow-ups and transient failures. Experiments on PTC-Bench show that I-PTC improves performance on complex multi-step tasks with large tool sets while substantially reducing token consumption over conventional tool-calling baselines and the original PTC baseline, highlighting stateful programmatic tool calling as a promising direction for scalable tool-augmented agents.

## Eliminating Servers in State Machine Replication

DevFeed: [Eliminating Servers in State Machine Replication](<https://devfeed.tech/articles/eliminating-servers-in-state-machine-replication-113645.md>)

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

Author: Dohyun Park, Wenjie Hu, Xiangyao Yu, Mahesh Balakrishnan, Yongjoo Park

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

Content type: article

Language: en

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

Topics: [Raft](<https://devfeed.tech/topics/raft.md>), [etcd](<https://devfeed.tech/topics/etcd.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [client](<https://devfeed.tech/tags/client.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-databases](<https://devfeed.tech/tags/distributed-databases.md>), [etcd](<https://devfeed.tech/tags/etcd.md>), [faster](<https://devfeed.tech/tags/faster.md>), [interface](<https://devfeed.tech/tags/interface.md>), [key-value-store](<https://devfeed.tech/tags/key-value-store.md>), [latency](<https://devfeed.tech/tags/latency.md>), [materialization](<https://devfeed.tech/tags/materialization.md>), [metadata](<https://devfeed.tech/tags/metadata.md>), [order](<https://devfeed.tech/tags/order.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [paper](<https://devfeed.tech/tags/paper.md>), [provisioning](<https://devfeed.tech/tags/provisioning.md>), [raft](<https://devfeed.tech/tags/raft.md>), [replication](<https://devfeed.tech/tags/replication.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [state-machine](<https://devfeed.tech/tags/state-machine.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

Serverless SMR (S²MR) stores both the durable command order and materialized state on disaggregated storage, with clients concurrently maintaining a single shared state copy. The authors argue the shared log can support distributed state materialization as well as command ordering, making it the interface for SMR without server-based state storage and snapshot serving. Their demonstration, AirDB, is a transactional key-value store. In the reported evaluation, AirDB over S²MR was more available than existing SMR systems such as etcd over Raft, remained unaffected by server failures and bad client activity, and started 10-45 times faster from a cold start.

### Source excerpt

arXiv:2611.01363v1 Announce Type: new Abstract: State Machine Replication (SMR) underpins many stateful systems, including distributed databases, coordination services, and metadata stores. Fundamentally, SMR requires state to be materialized from a durable total order of commands. Existing SMR systems rely on servers to materialize, locally store, and serve snapshots of state; while the durable total order either resides on the same servers, or on an external, disaggregated shared log. Unfortunately, servers act as brittle, expensive choke-points in such systems, causing service unavailability when they fail; incurring provisioning latency on cold starts; and red-lining when exposed to bad clients. In this paper, we propose Serverless SMR (S^2MR), where both the materialized state and the durable total order are stored on disaggregated storage; clients concurrently maintain a single copy of materialized state on external storage. Our key technical insight is that the shared log abstraction is useful not just for consistently ordering commands in SMR, but also for enabling distributed materialization, thus becoming the only interface for ac hieving SMR. We demonstrate S^2MR by developing AirDB, a transactional key-value store. In our evaluation, AirD B over S^2MR achieves higher availability than existing SMR-based systems like etcd over Raft: it is oblivious to server failures and bad client activity; and spins up 10x-45x faster from a cold start.

## RecHash: Segmented Hash-Entangled Chains for Stateful Sequential Authentication

DevFeed: [RecHash: Segmented Hash-Entangled Chains for Stateful Sequential Authentication](<https://devfeed.tech/articles/rechash-segmented-hash-entangled-chains-for-stateful-sequential-authentication-109092.md>)

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

Author: Luis Adri\\'an Lizama-P\\'erez

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

Content type: article

Language: en

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

Topics: [Authentication](<https://devfeed.tech/topics/authentication.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [hashing](<https://devfeed.tech/topics/hashing.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [construction](<https://devfeed.tech/tags/construction.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [digest](<https://devfeed.tech/tags/digest.md>), [hash](<https://devfeed.tech/tags/hash.md>), [records](<https://devfeed.tech/tags/records.md>), [security](<https://devfeed.tech/tags/security.md>), [stateful](<https://devfeed.tech/tags/stateful.md>)

### AI overview

RecHash authenticates records sequentially using paired hash-chain openings and an authenticated record history. It assigns each record to a predetermined chain segment, encoding digest blocks through complementary positions so every digest fits its scheduled slot regardless of earlier messages. For an ℓ-bit digest across k equal-length chain pairs, balanced allocation yields ⌊L/(2^⌈ℓ/k⌉+1)⌋ slots. The stated example uses a 256-bit digest, 32 pairs and chain length 65535 to support 254 application records followed by a renewal certificate, with 2048 bytes of openings per record for 256-bit chain outputs. The work gives a renewal-free security-composition theorem conditional on authenticated history and an adaptive one-step guarantee; it leaves a concrete post-quantum reduction and security across renewal open.

### Source excerpt

arXiv:2610.40507v1 Announce Type: new Abstract: RecHash is a stateful sequential authentication construction based on paired hash-chain openings and an authenticated record history. It develops the decreasing position relation of the 2019 hash-entangled construction, whose exact integer normalization yields a two-coordinate constant-sum antichain. Direct proportional reuse is constrained by integer capacity and multiplicative contraction. The main construction instead assigns each record to a predetermined chain segment, with complementary positions encoding each digest block. All digests fit every scheduled slot, independently of preceding messages. For an $\ell$-bit digest distributed over $k$ equal-length chain pairs, balanced allocation gives $\lfloor L/(2^{\lceil\ell/k\rceil}+1)\rfloor$ slots. A 256-bit digest, 32 pairs, and length 65535 provide 254 application records followed by a renewal certificate, with 2048 bytes of openings per record for 256-bit chain outputs. We give a complete segmented state transition, a worked trace, exact allocation and resource results, and a renewal-free security-composition theorem conditional on authenticated history and an adaptive one-step guarantee. The analysis relates the construction to constant-sum encodings and standardized hash-based signatures; a concrete post-quantum reduction and security across renewal remain open.

## Cassette-Editor: A Video Editing Agent That Edits the Way You Do

DevFeed: [Cassette-Editor: A Video Editing Agent That Edits the Way You Do](<https://devfeed.tech/articles/cassette-editor-a-video-editing-agent-that-edits-the-way-you-do-107948.md>)

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

Author: Zhixin Zeng, Jiahao Zhong

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

Content type: news

Language: en

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

Topics: [generative-ai-tools](<https://devfeed.tech/topics/generative-ai-tools.md>), [function calling](<https://devfeed.tech/topics/function-calling.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-mm](<https://devfeed.tech/tags/cs-mm.md>), [video](<https://devfeed.tech/tags/video.md>), [video-editing](<https://devfeed.tech/tags/video-editing.md>)

### AI overview

Cassette-Editor uses one tool to read a video project and one to write edits through the same executor, rules, and commit service as manual edits. Writes either commit atomically or are rejected with located diagnostics and repair options; the model retains creative control and decides how to recover. Reads connect stored footage analysis to each use on the timeline. In a controlled experiment, a real model corrected nearly all of 277 deliberately damaged edits with full or minimal feedback. Locating each problem reduced correction input tokens to less than half, and the model dropped other values it had written in one correction case rather than seven.

### Source excerpt

arXiv:2610.37690v1 Announce Type: cross Abstract: Language agents increasingly work by calling tools on a persistent artifact, such as a code repository, and the result of each call shapes their next step. Video editing is a demanding case of this pattern: what a frame shows depends on how every clip is trimmed, retimed, cropped, and nested, so knowledge about the footage holds only for particular uses of it, and an invalid edit can leave the timeline structurally broken. Existing video editing agents keep their edits valid with critic agents, reviewers, or restricted output formats. We present Cassette-Editor, a video editing agent with a deliberately simple interface: one tool reads the project and one tool writes to it. Every write passes through the same executor, rules, and commit service as the user's manual edits, and either commits atomically or is rejected with located diagnostics and repair options, while the model keeps the creative choices and decides how to recover. Reads relate stored analysis of the footage to each use of it on the timeline. In a controlled experiment, a real model is shown 277 of its own committed edits after damaging them. It corrected nearly every call with full or minimal feedback, but locating each problem cut the input tokens a correction needed to less than half, and its corrections dropped other values the model had written in one case rather than seven.

## CTE-Bench: Counterfactual Trace Evaluation for Stateful Software Simulators

DevFeed: [CTE-Bench: Counterfactual Trace Evaluation for Stateful Software Simulators](<https://devfeed.tech/articles/cte-bench-counterfactual-trace-evaluation-for-stateful-software-simulators-107355.md>)

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

Author: Xinran Zhang

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

Content type: article

Language: en

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

Topics: [Stateful](<https://devfeed.tech/topics/stateful.md>), [Software](<https://devfeed.tech/topics/software.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [bench](<https://devfeed.tech/tags/bench.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [claude](<https://devfeed.tech/tags/claude.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [deepseek](<https://devfeed.tech/tags/deepseek.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [kimi](<https://devfeed.tech/tags/kimi.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [predictions](<https://devfeed.tech/tags/predictions.md>), [python](<https://devfeed.tech/tags/python.md>), [qwen3-6](<https://devfeed.tech/tags/qwen3-6.md>), [score](<https://devfeed.tech/tags/score.md>), [scripts](<https://devfeed.tech/tags/scripts.md>), [service](<https://devfeed.tech/tags/service.md>), [software](<https://devfeed.tech/tags/software.md>), [state](<https://devfeed.tech/tags/state.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [trace](<https://devfeed.tech/tags/trace.md>), [v1](<https://devfeed.tech/tags/v1.md>)

### AI overview

CTE-Bench evaluates whether models can predict how code edits or state overwrites change a deterministic service's future responses. In each scenario, a model receives Python service code, the pre-intervention call history, an intervention, and 40 fixed future calls; an executable oracle checks its predictions. Three protocols vary whether correct prior responses, no prior responses, or the model's own predictions are available. Across 255 scenarios and six services, four API-hosted models achieved 54.3%-61.7% exact-match accuracy on intervention-affected calls when given correct feedback. Accuracy fell to 23.2%-29.0% without that feedback and was 24.8%-33.2% when models relied on their own predictions; at most 1.2% of scenarios were predicted exactly end to end. The results suggest errors compound across a rollout. The release includes the benchmark, executable oracle, evaluation scripts, and an evaluation card.

### Source excerpt

arXiv:2609.36647v2 Announce Type: replace Abstract: Coding agents change running software: they patch a service's code or overwrite its stored state, and then act on their own expectation of how the service will respond afterwards. A wrong expectation may surface only several calls later. Function-level code-execution benchmarks omit persistent service state, and agent benchmarks score the actions an agent takes or the final state it reaches. We introduce CTE-Bench, which measures whether a model can predict how an intervention changes a stateful service's future behavior, without asking it to choose actions. Each scenario gives the model Python service code, the calls and responses observed before the intervention, the intervention itself (a source edit or a state overwrite), and 40 fixed future calls; the model predicts every future response, and predictions are checked by executing the service. Three memory protocols control whether the model sees the correct earlier responses, none of them, or its own earlier predictions. CTE-Bench-Core-v1 contains 255 scenarios over six deterministic Python services, giving 10,200 predictions per model. The main score is effect-step value match (VM): exact response equality on the 2,476 future calls whose response the intervention changes. With correct earlier responses revealed, four API-hosted models (DeepSeek V4-Flash, Kimi K2.5, Qwen3.6-35B-A3B, and Claude Sonnet 4.6) reach 54.3%-61.7% effect-step VM. Hiding those responses lowers effect-step VM to 23.2%-29.0%; conditioning on self-generated predictions gives 24.8%-33.2%, and at most 1.2% of scenarios are predicted exactly end to end. Current models thus track intervention effects mainly when correct feedback is supplied, and their errors compound over a rollout. We release CTE-Bench-Core-v1 with its executable oracle, evaluation scripts, and an evaluation card mapping each claim to its protocol.

## Uber Moves Beyond CPU Cores with Performance-Aware Scheduling for Stateful Workloads

DevFeed: [Uber Moves Beyond CPU Cores with Performance-Aware Scheduling for Stateful Workloads](<https://devfeed.tech/articles/uber-moves-beyond-cpu-cores-with-performance-aware-scheduling-for-stateful-workloads-102114.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/10/uber-cpu-stateful-workloads/>)

Author: Craig Risi

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

Content type: article

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [resource orchestration](<https://devfeed.tech/topics/resource-orchestration.md>), [Load Balancing](<https://devfeed.tech/topics/load-balancing.md>)

Tags: [1-4](<https://devfeed.tech/tags/1-4.md>), [abstraction](<https://devfeed.tech/tags/abstraction.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-ml-data-engineering](<https://devfeed.tech/tags/ai-ml-data-engineering.md>), [apache-kafka](<https://devfeed.tech/tags/apache-kafka.md>), [arm](<https://devfeed.tech/tags/arm.md>), [automation-in-the-cloud-and-management-at-scale](<https://devfeed.tech/tags/automation-in-the-cloud-and-management-at-scale.md>), [aws](<https://devfeed.tech/tags/aws.md>), [balancing](<https://devfeed.tech/tags/balancing.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [compute](<https://devfeed.tech/tags/compute.md>), [core](<https://devfeed.tech/tags/core.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cpu-time](<https://devfeed.tech/tags/cpu-time.md>), [data-centres](<https://devfeed.tech/tags/data-centres.md>), [devops](<https://devfeed.tech/tags/devops.md>), [fleet](<https://devfeed.tech/tags/fleet.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [make](<https://devfeed.tech/tags/make.md>), [ml-data-engineering](<https://devfeed.tech/tags/ml-data-engineering.md>), [news](<https://devfeed.tech/tags/news.md>), [performance](<https://devfeed.tech/tags/performance.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [server](<https://devfeed.tech/tags/server.md>), [state-machine](<https://devfeed.tech/tags/state-machine.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [uber](<https://devfeed.tech/tags/uber.md>), [uber-cpu-stateful-workloads](<https://devfeed.tech/tags/uber-cpu-stateful-workloads.md>), [units](<https://devfeed.tech/tags/units.md>)

### AI overview

Uber's Normalized Compute Units (NCUs) let Odin allocate comparable compute capacity across servers whose CPU performance varies substantially. Odin assigns each server type a performance factor, initially measured during hardware qualification and refined with production workload data, then uses it to translate workload requirements into different numbers of physical cores. This addresses a reliability risk for stateful workloads, which cannot readily shift requests away from a slower server; stateless services can more often use load balancing. Across about 1.4 million automatically scaled cores, Kafka's utilization gap between server types fell from roughly eight to three percentage points, and total Kafka CPU allocation dropped about 8%. Uber contrasts NCUs with Kubernetes CPU requests in cores or millicores, which represent CPU time without expressing relative processor performance.

### Source excerpt

Uber has introduced Normalized Compute Units (NCUs) to make CPU allocation more consistent across its highly heterogeneous server fleet. By Craig Risi

## Phantom Forgetting: How BatchNorm State Fakes Deletion in Edge Split Machine Unlearning

DevFeed: [Phantom Forgetting: How BatchNorm State Fakes Deletion in Edge Split Machine Unlearning](<https://devfeed.tech/articles/phantom-forgetting-how-batchnorm-state-fakes-deletion-in-edge-split-machine-unlearning-101439.md>)

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

Author: Anand Agrawal, Anil Kumar Chillara, Naresh Mandan

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

Content type: article

Language: en

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

Topics: [ai security](<https://devfeed.tech/topics/ai-security.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>)

Tags: [checkpoint](<https://devfeed.tech/tags/checkpoint.md>), [cifar-10](<https://devfeed.tech/tags/cifar-10.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [data-drift](<https://devfeed.tech/tags/data-drift.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [edge](<https://devfeed.tech/tags/edge.md>), [edge-security](<https://devfeed.tech/tags/edge-security.md>), [machine-unlearning](<https://devfeed.tech/tags/machine-unlearning.md>), [over-the-air-updates](<https://devfeed.tech/tags/over-the-air-updates.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [split](<https://devfeed.tech/tags/split.md>), [state](<https://devfeed.tech/tags/state.md>)

### AI overview

BatchNorm running statistics can create an apparent forgetting signal in split learning even when all learnable weights remain unchanged, so forget-set accuracy alone is not a reliable deletion certificate. On CIFAR-10 across ten forget classes, recalibrating BN on forget data reduced mean forget accuracy by 61.50 percentage points centrally; in split models, the drops were 37.27 points for edge-only, 41.71 for server-only, and 51.90 for joint recalibration. Server-side state produced the largest selective gap after accounting for retain-set degradation, while joint recalibration caused the largest overall prediction change. The abstract proposes separating weight changes from BN-buffer changes, localizing state changes by party, and auditing edge-aware state integrity.

### Source excerpt

arXiv:2610.34800v1 Announce Type: new Abstract: Split learning is a natural fit for edge intelligence: a resource-constrained edge device runs the first layers of a network and offloads the remainder to a server, so that raw data never leave the device. When such a system must unlearn revoked or sensitive data for example to honor a right-to-erasure request, the deletion is commonly assessed through changes in forget-set accuracy. However, inference on an edge-server split also depends on non-learnable model state distributed across the two parties, and this state is especially volatile on edge devices subject to data drift, over-the-air updates, and checkpoint rollback. This paper isolates a state-integrity question with direct edge-security implications: can Batch Normalization (BN) running statistics create a target-specific forgetting signal even when every learnable weight remains fixed? We define a state-only diagnostic that separates learnable-parameter change from BN- buffer change and localizes the effect to the edge (client) side, the server side, and joint placements. We also introduce a state-induced forgetting gap (SIFG) that discounts simultaneous retain-set degradation. Over all ten CIFAR-10 forget classes, centralized BN recalibration on forget data reduces mean forget accuracy by 61.50 percentage points with zero weight change; in a split model, edge-only, server-only, and joint recalibration produce mean drops of 37.27, 41.71, and 51.90 points. The server-side state yields the largest selective gap relative to retain degradation, while joint recalibration causes the largest overall prediction change. These results establish distributed normalization buffers including those held on the edge device as security and privacy-relevant inference state, and show that forget accuracy should not be interpreted, or accepted as a deletion certificate, without an explicit edge-aware state-integrity audit.

## Optimizing your runs for lower compute, fresher data, and faster iteration with dbt State

DevFeed: [Optimizing your runs for lower compute, fresher data, and faster iteration with dbt State](<https://devfeed.tech/articles/optimizing-your-runs-for-lower-compute-fresher-data-and-faster-iteration-with-dbt-state-101830.md>)

Original publisher: [Read original article](<https://www.getdbt.com/blog/dbt-state-orchestration-jobs-19-to-2>)

Author: Daniel Poppy

Published: 2026-10-26T21:53:00Z

Content type: news

Language: en

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

Topics: [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [compute](<https://devfeed.tech/tags/compute.md>), [data](<https://devfeed.tech/tags/data.md>), [dbt](<https://devfeed.tech/tags/dbt.md>), [faster](<https://devfeed.tech/tags/faster.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [jobs](<https://devfeed.tech/tags/jobs.md>), [learn](<https://devfeed.tech/tags/learn.md>), [model](<https://devfeed.tech/tags/model.md>), [optimizing](<https://devfeed.tech/tags/optimizing.md>), [rules](<https://devfeed.tech/tags/rules.md>), [state](<https://devfeed.tech/tags/state.md>)

### AI overview

dbt State aims to make each run build only what changed by tracking warehouse state. In production, teams declare model-level freshness tolerance and rules for what counts as new source data; dbt Labs says this replaced 19 scheduled jobs with two. In development, auto-cloning and auto-deferral let users test a model without rebuilding upstream models or manually managing manifest files. A Fanatics pilot reported 25-30% model reuse and roughly 15% Snowflake savings. The described features include skipping unchanged models, zero-copy cloning, and explanations for why a model did or did not build. Limits: dbt State does not replace source freshness alerting, views rebuild when their underlying query changes, and snapshots are exempt. The article says it is available for dbt 1.7-1.12 via pip, built into dbt v2, and enabled with a checkbox on the dbt platform.

### Source excerpt

dbt State turns freshness rules into model-level code, and it took dbt Labs' own project from nineteen scheduled jobs down to two.

## Stateful Agentic Engineering Copilots with Letta: Core Memory, Shared State, Semantic Retrieval, Custom Tools, Streaming, and Portable Agent Workflows

DevFeed: [Stateful Agentic Engineering Copilots with Letta: Core Memory, Shared State, Semantic Retrieval, Custom Tools, Streaming, and Portable Agent Workflows](<https://devfeed.tech/articles/stateful-agentic-engineering-copilots-with-letta-core-memory-shared-state-semantic-retrieval-custom-tools-streaming-and-portable-agent-workflows-98777.md>)

Original publisher: [Read original article](<https://www.marktechpost.com/2026/10/24/stateful-engineering-copilots-letta-tutorial/>)

Author: Sana Hassan

Published: 2026-10-24T10:29:31Z

Content type: tutorial

Language: en

Sources: [MarkTechPost](<https://devfeed.tech/sources/marktechpost.md>)

Topics: [Stateful](<https://devfeed.tech/topics/stateful.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-workflows](<https://devfeed.tech/tags/agent-workflows.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agentic-memory](<https://devfeed.tech/tags/agentic-memory.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [building](<https://devfeed.tech/tags/building.md>), [context-engineering](<https://devfeed.tech/tags/context-engineering.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [core](<https://devfeed.tech/tags/core.md>), [custom](<https://devfeed.tech/tags/custom.md>), [editors-pick](<https://devfeed.tech/tags/editors-pick.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [for-devs](<https://devfeed.tech/tags/for-devs.md>), [letta](<https://devfeed.tech/tags/letta.md>), [memory](<https://devfeed.tech/tags/memory.md>), [portable](<https://devfeed.tech/tags/portable.md>), [retrieval](<https://devfeed.tech/tags/retrieval.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [state](<https://devfeed.tech/tags/state.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [streaming](<https://devfeed.tech/tags/streaming.md>), [tools](<https://devfeed.tech/tags/tools.md>), [tutorials](<https://devfeed.tech/tags/tutorials.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>), [with](<https://devfeed.tech/tags/with.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

The tutorial shows how to build a persistent engineering copilot with Letta by combining inspectable core memory, archival semantic retrieval, shared memory blocks, custom tools, streaming, server-side history, and agent export. Core memory can be updated by the agent or synchronized directly by application code; shared blocks let a copilot and reviewer exchange state, with some blocks marked read-only. Tagged archival passages support semantic search. A server-side tool demonstrates deterministic release-risk scoring, while streaming exposes execution steps and server-side history preserves conversations across local processes. The tutorial also presents .af export and import for portability. It describes an integrated workflow, without establishing comparative performance or broader reliability claims.

### Source excerpt

Discover how to extend agentic memory beyond basic prompts by building a stateful engineering copilot with Letta. This comprehensive guide covers inspectable core memory, archival vector retrieval, multi-agent shared state, custom tools, and portable workflows. The post Stateful Agentic Engineering Copilots with Letta: Core Memory, Shared State, Semantic Retrieval, Custom Tools, Streaming, and Portable Agent Workflows appeared first on MarkTechPost.

## Stateful vs. Stateless: Managing Context in AI Agent Builds

DevFeed: [Stateful vs. Stateless: Managing Context in AI Agent Builds](<https://devfeed.tech/articles/stateful-vs-stateless-managing-context-in-ai-agent-builds-96010.md>)

Original publisher: [Read original article](<https://blog.n8n.io/stateful-vs-stateless/>)

Author: n8n team

Published: 2026-10-22T15:44:39Z

Content type: article

Language: en

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

Topics: [Stateful](<https://devfeed.tech/topics/stateful.md>), [stateless](<https://devfeed.tech/topics/stateless.md>), [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [context](<https://devfeed.tech/topics/context.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-memory](<https://devfeed.tech/tags/agent-memory.md>), [agent-state](<https://devfeed.tech/tags/agent-state.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-workflows](<https://devfeed.tech/tags/agentic-workflows.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agent-memory](<https://devfeed.tech/tags/ai-agent-memory.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-native](<https://devfeed.tech/tags/ai-native.md>), [context](<https://devfeed.tech/tags/context.md>), [design](<https://devfeed.tech/tags/design.md>), [guide](<https://devfeed.tech/tags/guide.md>), [memory](<https://devfeed.tech/tags/memory.md>), [scale](<https://devfeed.tech/tags/scale.md>), [state](<https://devfeed.tech/tags/state.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [stateless](<https://devfeed.tech/tags/stateless.md>), [systems](<https://devfeed.tech/tags/systems.md>), [vs](<https://devfeed.tech/tags/vs.md>)

### AI overview

Stateless execution makes requests easier to distribute and recover, while stateful behavior preserves continuity but requires state to be stored and available. LLMs do not retain prior requests automatically; agents can retrieve stored context and add it to later inputs. In n8n, executions are independent by default. Simple Memory buffers recent session messages but is incompatible with queue mode; Postgres Chat Memory persists conversations by session ID, and Redis Chat Memory can share session state across workers. Chat Memory Manager allows workflows to load, insert, and clear messages. For data that must persist across executions, n8n data tables or workflow static data and external Postgres or Redis stores are options. The text recommends keeping execution stateless where possible and adding session memory or durable shared storage where continuity requires it.

### Source excerpt

Stateful versus stateless design changes how systems scale and remember context. Learn when to use memory nodes, state stores, or both.

## Koala: Non-disruptive Reconfiguration for Long-running Stateful Dataflows

DevFeed: [Koala: Non-disruptive Reconfiguration for Long-running Stateful Dataflows](<https://devfeed.tech/articles/koala-non-disruptive-reconfiguration-for-long-running-stateful-dataflows-95160.md>)

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

Author: Lei Huang, Sakshi Sharma, Chenxu Yu, Zikun Wang, Yuanli Wang, Zichen Zhu, John Liagouris, Vasiliki Kalavri

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

Content type: article

Language: en

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

Topics: [streaming data analytics](<https://devfeed.tech/topics/streaming-data-analytics.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [all](<https://devfeed.tech/tags/all.md>), [applications](<https://devfeed.tech/tags/applications.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [art](<https://devfeed.tech/tags/art.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [backlog](<https://devfeed.tech/tags/backlog.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [but](<https://devfeed.tech/tags/but.md>), [change](<https://devfeed.tech/tags/change.md>), [changes](<https://devfeed.tech/tags/changes.md>), [choice](<https://devfeed.tech/tags/choice.md>), [core](<https://devfeed.tech/tags/core.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dataflow](<https://devfeed.tech/tags/dataflow.md>), [design](<https://devfeed.tech/tags/design.md>), [designs](<https://devfeed.tech/tags/designs.md>), [disruption](<https://devfeed.tech/tags/disruption.md>), [long-running](<https://devfeed.tech/tags/long-running.md>), [running](<https://devfeed.tech/tags/running.md>), [stateful](<https://devfeed.tech/tags/stateful.md>)

### AI overview

Koala is a reconfiguration protocol for long-running stateful dataflows that aims to combine the steady-state performance of embedded state with disruption-free adaptability. Instead of migrating all state during reconfiguration, it moves state lazily and at fine granularity, using lightweight ownership transfers to decouple event routing from state location. In evaluations on real-world and synthetic benchmarks, Koala consumed backlog up to 23x faster and transferred 8.7x less state on average than DRRS. The supplied text is an abstract, so it does not provide further implementation details or evaluation conditions.

### Source excerpt

arXiv:2610.28939v1 Announce Type: new Abstract: Stateful dataflow systems must decide where state lives relative to the tasks that process it. For long-running applications that require frequent reconfiguration due to changes in resource allocation, partitioning, or task placement, this design choice presents a core trade-off between adaptability and performance. Co-locating state with computation ensures low latency at steady state but makes reconfiguration disruptive, as any change forces state migration. On the other hand, keeping state in an external store makes reconfiguration seamless, but incurs overhead on every access. We present Koala, a reconfiguration protocol for distributed dataflow systems that retains the operational performance of embedded-state architectures while matching the disruption-free adaptability of external-state designs. Unlike prior protocols which relocate all state regardless of whether it will soon be accessed, Koala migrates state in a fine-grained, lazy manner. To achieve that, it employs a lightweight ownership transfer mechanism that safely decouples event routing from state location. We implement Koala in a new streaming dataflow system and evaluate it on real-world and synthetic benchmarks. When compared with the state-of-the-art protocol DRRS, Koala consumes backlog up to 23x faster and transfers 8.7x less state on average during reconfiguration.

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