Paper deep dive
Agentic Transaction: Towards ACID-Compliant Agent Systems
Zhaoyan Sun, Xiaoxiao Wang, Guoliang Li
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 96%
Last extracted: 8/17/2026, 4:33:07 AM
Summary
The paper introduces 'Agentic Transaction,' a framework that adapts ACID (Atomicity, Consistency, Isolation, Durability) properties from database systems to Large Language Model (LLM) agents. It proposes an ACID-compliant data agent system that ensures reliable execution, consistent outcomes, safe concurrency, and durable state management through semantic guarantees like Semantic Atomicity, Semantic Consistency, Semantic Isolation, and Semantic Durability. The system utilizes transactional exploration-execution-validation cycles, confidence-based validation, and append-only workspaces to handle model uncertainty and dynamic environments, achieving a 10.6% performance improvement over state-of-the-art agents like Claude Code.
Entities (10)
Relation Signals (8)
Agentic Transaction → enforces → Semantic Isolation
confidence 98% · We introduce the concept of an agentic transaction and propose an ACID-compliant agent system framework that reinterprets the classical ACID properties... through four semantic guarantees: Semantic Isolation...
Agentic Transaction → enforces → Semantic Durability
confidence 98% · We introduce the concept of an agentic transaction and propose an ACID-compliant agent system framework that reinterprets the classical ACID properties... through four semantic guarantees: Semantic Durability.
Agentic Transaction → enforces → Semantic Atomicity
confidence 98% · We introduce the concept of an agentic transaction and propose an ACID-compliant agent system framework that reinterprets the classical ACID properties... through four semantic guarantees: Semantic Atomicity...
Agentic Transaction → enforces → Semantic Consistency
confidence 98% · We introduce the concept of an agentic transaction and propose an ACID-compliant agent system framework that reinterprets the classical ACID properties... through four semantic guarantees: Semantic Consistency...
ACID-Agent → implements → Agentic Transaction
confidence 95% · We introduce the concept of an agentic transaction and propose an ACID-compliant agent system framework... To instantiate this framework, we develop an ACID-compliant data agent
ACID-Agent → uses → Append-Only Workspace
confidence 94% · ACID-Agentmaintains an append-only workspace that records committed transaction states
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Large language model (LLM) agents are evolving from conversational assistants into autonomous systems that execute long-horizon tasks through reasoning, tool use, code generation, and workspace manipulation. As agents increasingly operate over persistent environments and multi-step workflows, they face challenges analogous to those addressed by transactional database systems: reliable execution, consistent outcomes, safe concurrency, and durable state management. We introduce the concept of an agentic transaction and propose an ACID-compliant agent system framework that reinterprets the classical ACID properties for agent execution through four semantic guarantees: Semantic Atomicity, Semantic Consistency, Semantic Isolation, and Semantic Durability. Together, these properties provide a principled foundation for building reliable agent systems despite model uncertainty and dynamic execution environments. To instantiate this framework, we develop an ACID-compliant data agent that realizes these guarantees through transactional exploration-execution-validation cycles, transactional skill hubs, confidence divergence-based validation, semantic dependency-aware isolation, and transaction-aware semantic state management. Experimental results on widely used benchmarks show that our system achieves a 10.6% improvement over state-of-the-art agents, including Claude Code. This work opens a broader research agenda on extending transactional principles and system architectures toward building trustworthy, scalable, and self-evolving AI agent systems.
Tags
Links
- Source: https://arxiv.org/abs/2608.13900v1
- Canonical: https://arxiv.org/abs/2608.13900v1
Trouble viewing inline? Open PDF directly →
Full Text
37,813 characters extracted from source content.
Expand or collapse full text
Agentic Transaction: Towards ACID-Compliant Agent Systems Zhaoyan Sun Tsinghua University szy22@mails.tsinghua.edu.cn Xiaoxiao Wang Tsinghua University xw724@cornell.edu Guoliang Li Tsinghua University liguoliang@tsinghua.edu.cn ABSTRACT Large language model (LLM) agents are evolving from conver- sational assistants into autonomous systems that execute long- horizon tasks through reasoning, tool use, code generation, and workspace manipulation. As agents increasingly operate over per- sistent environments and multi-step workflows, they face chal- lenges analogous to those addressed by transactional database sys- tems: reliable execution, consistent outcomes, safe concurrency, and durable state management. We introduce the concept of an agentic transaction and propose an ACID-compliant agent system framework that reinterprets the classical ACID properties for agent execution through four semantic guarantees: Semantic Atomic- ity, Semantic Consistency, Semantic Isolation, and Semantic Durability. Together, these properties provide a principled founda- tion for building reliable agent systems despite model uncertainty and dynamic execution environments. To instantiate this frame- work, we develop an ACID-compliant data agent that realizes these guarantees through transactional exploration-execution-validation cycles, transactional skill hubs, confidence divergence-based valida- tion, semantic dependency-aware isolation, and transaction-aware semantic state management. Experimental results on widely used benchmarks show that our system achieves a 10.6% improvement over state-of-the-art agents, including Claude Code. This work opens a broader research agenda on extending transactional princi- ples and system architectures toward building trustworthy, scalable, and self-evolving AI agent systems. 1 INTRODUCTION Recent advances in large language models (LLMs) have demon- strated strong capabilities in instruction following, planning, rea- soning, coding, tool use, and data processing [12,18–22,24,25]. As a result, LLM usage is shifting from single-round conversational interactions toward long-horizon production tasks, where agents operate over repository-level workspaces and autonomously co- ordinate iterative reasoning, code execution, and feedback-driven refinement over extended periods. We refer to such a multi-round task-centered interactions between LLMs and execution environ- ments as an agentic transaction (see Figure 1), where execution operates over semantic task states rather than structured database states. Although agent systems differ fundamentally from databases, they face analogous challenges in ensuring reliable execution, con- sistent outcomes, safe concurrency, and persistent state management. Motivated by these parallels, we envision an ACID-Compliant Agent System that reinterprets the classical ACID properties [10] for agen- tic transactions: Semantic Atomicity. Similar to how database systems encapsulate recurring application logic into reusable procedures and transaction abstractions, agent systems increasingly rely on reusable skills that package tools, workflows, and domain knowledge into coherent op- erational units [1]. We define semantic atomicity as the property that User Question For Boston Harbor beaches located in communities with more than 90% EJ populations, what is the Pearson correlation, rounded to 3 decimal places, between rainfall in the past 3 days and Enterococcus levels? Atomic Semantic Transaction Unit Data Exploration (Wollaston Beach) 1-Day Rain 2-Day Rain 3-Day Rain Entero- coccus ............ Datasheets: Milton Road, Channing Street, Sachem Street, Rice Road Date ... Aggregate 4 locations into one daily Enterococcus value. Claude Code #Observations: 1904 Answer: 0.261 Consistency Validation Aggregate 4 locations within each date. Current DecisionAlternative Each location-date as an observation. vs Low LLM Confidence ! (Evidence-based) Keep each location- date separately. ACID-Agent (Retry) #Observations: 7585 Answer: 0.206 · Add validated steps to context memory. Durability · Commit to append-only workspace. (7.7k → 0.7k tokens) Isolation · No failed steps in workspace & memory. Figure 1: An Example of ACID-Compliant Data Agent. an agent transaction treats a dependency-aware sequence of model invocations, tool calls, document mutations, and external actions as a single semantic unit of execution: its effects become visible only after required operations and validations succeed; otherwise, recoverable effects are rolled back or compensated. The challenge is that agent workflows are long-running, dynamically generated, and often involve non-transactional external resources, where par- tial execution may leave inconsistent workspaces or unsupported results [8,17]. For example, as shown in Figure 1, conventional coding agents such as Claude Code may propagate intermediate decisions directly. In contrast,ACID-Agenttreats each exploration- execution-validation cycle as a semantic transaction, and only vali- dated updates are committed and propagated to subsequent steps. Semantic Consistency. Similar to consistency guarantees in databases, agent systems must ensure that committed results remain aligned with intended semantics despite potentially non-deterministic exe- cution [11]. We define semantic consistency as the property that an agent transaction produces outcomes that satisfy task objectives, execution constraints, and available evidence, even when inter- mediate reasoning traces vary across executions. This property is challenging because LLM-driven agents may generate syntactically executable plans that are semantically invalid due to incorrect tool selection, unsupported claims, stale observations, or divergence between user intent and execution results. For example, as shown arXiv:2608.13900v1 [cs.DB] 14 Aug 2026 Table 1: ACID properties for agentic transactions. Unlike conventional database transactions, agent transactions combine non-deterministic reasoning with heterogeneous, potentially non-transactional effects. The proposed semantics constrain committed effects rather than requiring deterministic execution traces. PropertyAgent-Transaction SemanticsSystems ChallengeTechniques AtomicityA dependency-aware set of model invoca- tions, tool calls, document mutations, and external actions. Its effects become visible only if all required operations and postcon- ditions succeed; otherwise, all recoverable effects are rolled back or compensated. Agent workflows are long-running, dynami- cally generated, and may invoke external tools. Failures can therefore leave partially updated workspaces, duplicated external actions, or out- puts unsupported by completed execution. Treating each exploration-execution- validation cycle as a semantic transac- tion unit with commit-or-retry seman- tics, validated effect-only commits, and test-driven transactional skill hubs. ConsistencyThe execution trace may be non- deterministic, but its committed outcome must satisfy the transaction’s precon- ditions, postconditions, and evidence obligations. LLM-generated plans can be syntactically exe- cutable yet semantically invalid because of incor- rect tool selection, unsupported claims, schema or policy violations, stale observations, and diver- gence between the user’s intent and the commit- ted outcome. A confidence-based validation mecha- nism that integrates multiple reliability signals, including execution errors, de- cision/code confidence divergence, and LLM-based reflection feedback, with materialized skill reuse. IsolationConcurrent agent transactions must not observe or produce semantically invalid in- terference. Their committed effects should be equivalent to an execution permitted by a declared isolation level, while allowing safe information sharing and collaboration. Conflicts extend beyond reads and writes to en- compass prompts, memory, intermediate artifacts, tool budgets, external side effects, and derived se- mantic state. Moreover, conflicts often cannot be identified in advance because agents discover re- sources dynamically during execution. Isolating agent and operation con- texts through dependency-aware iso- lation policies, isolated environments, versioned workspaces, and validation- based state control. DurabilityOnce committed, a transaction’s effects, evidence, and recovery metadata persist across failures, enabling its state to be re- constructed and audited independently of the transient LLM context. Agent state is distributed across conversation context, model outputs, tool responses, files, databases, and external services. Model and prompt evolution complicate deterministic replay and long-term interpretation of prior executions. Maintaining transaction-aware mem- ory and append-only workspaces through LLM-managed knowledge- graph evolution, provenance tracing, and version-aware recovery. in Figure 1, ourACID-Agentemploys a confidence-based validation mechanism that integrates multiple reliability signals, including execution errors, divergences in decision and code confidence, and feedback from LLM-based reflection. The mechanism grounds its assessments in evidence gathered during exploration and triggers refinement whenever confidence falls below a threshold. Semantic Isolation. Similar to concurrency control in database systems, modern agent systems increasingly execute multiple sub- agents in parallel to solve complex tasks [22]. We define semantic isolation as the property that concurrent agent transactions do not observe or produce semantically invalid interference: their committed effects should be equivalent to an execution permitted by a declared isolation policy, while still allowing safe informa- tion sharing and collaboration. For example, as shown in Figure 1, ACID-Agentisolates intermediate workspace states and interaction histories from failed retries, ensuring that unsuccessful attempts do not propagate to subsequent executions or agent memory. The challenge is that agent conflicts extend beyond traditional data accesses to prompts, memories, intermediate artifacts, tool budgets, external side effects, and derived semantic states, while resource dependencies are often discovered dynamically during execution. Semantic Durability. Similar to how database systems preserve transactional state and AI-native databases leverage historical trans- actions to improve future execution [16,18,23], agent systems must preserve semantic state beyond individual executions. We define semantic durability as the ability to maintain committed execution states, supporting evidence, and recovery metadata beyond the lifetime of a transaction, enabling future executions to reconstruct and interpret prior results independently of transient LLM con- texts. For example, as shown in Figure 1,ACID-Agentmaintains an append-only workspace that records committed transaction states, updating memory only with validated execution units while discard- ing failed attempts. This property is challenging because agent state is distributed across conversations, model outputs, tool interactions, files, databases, and external services, while evolving models and prompts complicate reliable replay and long-term interpretation. Contributions. In summary, we make the following contributions: (1) We introduce a novel concept of agentic transactions and an ACID-compliant agent system framework, which extends the classi- cal ACID properties to agent execution and provides a principled foundation for designing reliable agent systems. (2) We propose an ACID-compliant data agent system: (A) in- troduces semantic atomicity by modeling exploration-execution- validation cycles as transaction units with commit-or-retry seman- tics, supported by transactional skill hubs and staged execution; (C) ensures semantic consistency through confidence divergence- based validation of critical decisions and generated code, integrat- ing execution signals and LLM feedback to detect unsupported behaviors and trigger evidence-guided retries; (I) enables seman- tic isolation by regulating dependencies among agents, contexts, and operations through adaptive coordination strategies, isolated execution environments, and versioned workspaces; (D) achieves semantic durability through transaction-aware memory, append- only workspace management, and persistent execution traces for recovery and long-horizon reasoning (see Section 2). (3) Our preliminary experimental results demonstrate the poten- tial advantages of transactionally designed agent systems (see Sec- tions 3). We also provide open research problems for extending agen- tic transactions to the full lifecycle of agent systems (see Section 4). The source code is available at https://github.com/TsinghuaDatabaseGroup/ ACID-Agent. 2 User Input TaskDataset Confidence-Guided Data Exploration Generate Code Execute (Read-Only) Observation → Evidences PLLM(Explore | Evidences) High → Redundant ! Consolidate Evidences Stop Continue Generate CodeExecute (Append-Only) Confidence-based Consistency Validation Extract Structured Decisions (Explored / Executed) PLLM(Executed | Evidences) / PLLM(Explored | Evidences) Low → Poorly Grounded ! Extract Executed Code Snippets PLLM(Code | Evidences) Low → Poorly Grounded ! Retry Judge Evidences Retry with Feedback Atomic Semantic Transaction Unit Commit Results Results Safe Skill Hub: Collect Repo./Paper/Workflows Benchmarks → Test Suites Test-Driven Skill Creation Workload- & Data-Aware Skill Router Workflows Failed Cases Consistent Skill Invocation with Atomicity & Isolation Safeguard Agent Spawn Tool with Dependency-Aware Isolation Tuner IndependentCollaborativeCompetitive Durable Transaction State Maintenance Append-Only WorkspaceMemory Evolution Op. Context Memory (Graph) Figure 2: Overview of ACID-Compliant Data Agent System. 2 AGENTIC TRANSACTION 2.1 Preliminaries LLM-based agents can solve tasks through long-horizon cycles of LLM reasoning, tool/skill invocation, and execution feedback. We refer to such multi-round task-centric interactions between LLMs and environments as agentic transactions. Definition 2.1 (Agentic Transaction). An agentic transaction,휏, is a bounded unit of agent execution comprising a finite sequence of LLM-driven interactions between an agent and its execution environment, undertaken to accomplish a task. Formally, given a tool set푇and a skill set푆, an agentic transaction휏= ⟨푟 1 , . . . ,푟 푛 ⟩ comprises푛steps. Each step푟 푖 = (푐 푖 , 푎 푖 , 푓 푖 )consists of an LLM context푐 푖 (including the tools in푇and skills in푆available at that step), an agent action푎 푖 that invokes a tool or skill, and the result- ing feedback푓 푖 from the environment. The transaction휏commits only if its execution satisfies the required task conditions and pre- serves all semantic invariants. Otherwise, its intermediate effects are rolled back or compensated for to ensure that no invalid side effects remain. For example, Figure 1 presents a data-agent transaction. It begins with LLM-driven exploration of datasets and schemas, followed by iterative analysis steps that invoke tools, update the workspace, and refine decisions based on feedback. Each exploration-execution- validation cycle forms a semantic transaction unit whose effects are propagated only after validation. Failed units are discarded or recovered without affecting the committed state. Table 1 summarizes representative challenges and techniques for achieving the ACID properties of agentic transactions. 2.2 An ACID-Compliant Data Agent System Data agents aim to automate data science workflows, derive insights from heterogeneous data, and manage data systems. Based on agen- tic transaction principles, we propose an ACID-compliant data agent system, as shown in Figure 2, providing reliability guarantees for exploration, execution, and transactional state evolution. 2.2.1 Semantic Atomicity. We propose two mechanisms for se- mantic atomicity: an offline skill hub that embeds transactional safeguards into reusable skills, and an online staged-execution framework that enforces commit-or-retry semantics via validation gates. Offline Skill Hub Creation. Under semantic atomicity, tools and skills become first-class transactional objects with lifecycle interfaces, and only validated effects are committed. We envision targeted skill hubs that automatically enforce transactional seman- tics, including rollback and commit, without requiring agents to perform manual transaction management. First, for workspace- modifying skills, this requires preventing invalid partial updates and side effects through idempotency keys, write-ahead action logs, checkpointing, and automatic compensation. Second, for system optimization skills, it further requires avoiding regressions caused by conflicting skill interactions. Realizing such skill hubs requires distilling existing data management expertise into deployable agent skills with adaptive routing and built-in transactional guarantees. We address this by packaging existing repositories as agent skills with standardized CLIs and validating their behavior through LLM- generated test suites derived from established benchmarks. We further develop a workload- and data-aware skill router that peri- odically analyzes historical system logs, uses LLM to summarize 3 SA () SA () SA () DA () DA () DA () C () C () C () CX () CX () CX () 0 25 50 Score (%) Figure 3: Consistency of Agent Performance Across Three Runs on 10 AgenticDataBench [19] Tasks. Bars show mean perfor- mance; error bars show the square root of the average per-task variance across runs. SA=Smolagents, DA=DA-Agent, C=Claude Code, CX=CodeX.➀=Qwen3.5-397B-A17B,➁=Kimi-K2.5,➂=Claude Sonnet 4.6. evolving workload characteristics, and dynamically adjusts feature importance for both skill retrieval and LLM-based skill selection. Online Semantic Transaction Execution. When existing skills with built-in safeguards are unavailable, we enforce semantic atom- icity through an online semantic transaction framework. Specifi- cally, we model the agent trajectory as a sequence of exploration- execution-validation cycles, with each cycle treated as a seman- tic transaction unit governed by commit-or-retry semantics. First, confidence-guided data exploration enables agents to iteratively col- lect and consolidate evidence while avoiding redundant exploration. Second, confidence-based consistency validation verifies the reliabil- ity of agent decisions and generated code by integrating execution errors, confidence divergence, and LLM-based reflection signals. Violations beyond predefined thresholds trigger retry. The failed ex- ecution steps are discarded by isolating their intermediate contexts from memory and excluding their workspace updates, ensuring atomic state evolution through an append-only workspace. We first describe confidence-guided data exploration and defer the second component to Section 2.2.2. Specifically, given a task, the exploration sub-agent iteratively generates read-only exploration code using the task description and recent exploration summaries as context. After execution, the observations are summarized into exploration memory. To avoid redundant exploration, we use LLM confidence-based validation to compare the current exploration observation with and without previous observations as context (de- tailed in Section 2.2.2). A large confidence divergence indicates that the current exploration is heavily dependent on prior observations and provides limited new information. We terminate exploration when redundant exploration exceeds a predefined threshold. Ex- ploration summaries are further consolidated to resolve potential conflicts and maintain a consistent evidence base. 2.2.2 Semantic Consistency. Data agents exhibit execution incon- sistency under workflow and model uncertainties, with repeated runs showing substantial variance and occasional intent violations (see Figure 3). Thus, we develop complementary offline and online mechanisms. Offline, we reuse validated workflows and enhance model-level behavioral stability. Online, we detect and correct exe- cution deviations through trajectory-level consistency validation. Offline Consistency Enhancement.(푖)Workflow-Level Mate- rialization. Similar to materialized views in databases, successful execution workflows can be materialized into reusable agent skills with semantic validation logic. These skills are retrieved based on task semantics and execution context, with details discussed in Section 2.2.1.(푖)Model-Level Stability. Consistency also depends on model reliability. Existing benchmarks focus on single-run cor- rectness or best-of-N performance while overlooking execution stability. We envision consistency-oriented benchmarks to measure stability and guide targeted fine-tuning. Online Consistency Validation. To maintain execution consis- tency with task requirements and supporting evidence, we propose a confidence-based validation mechanism that integrates multiple reliability signals, including execution errors, decision/code confi- dence divergence, and LLM-based reflection feedback. A retry is triggered when any signal exceeds its predefined threshold, with the validation feedback incorporated into the agent context to guide subsequent exploration-execution attempts. The process terminates upon successful validation or reaching the retry limit. To operationalize confidence-based validation, we quantify LLM confidence as the exponential of the average token-level log proba- bility over the target output. Confidence divergence between two contexts is then measured by comparing their corresponding confi- dence scores. We instantiate this measure for different agent outputs as follows.(푖)Decision Confidence Divergence. For critical decisions (e.g., filter predicates), we use LLMs to extract explored decisions from exploration summary and executed decisions from code. Given the task and recent exploration summaries as context, we measure their confidence divergence; a low divergence indicates that the ex- ecuted decision does not gain stronger evidence support than alter- native explored decisions.(푖)Code Confidence Divergence. For code generation, we identify decision-relevant code spans through static code analysis (e.g., control flows), and evaluate their confidence with and without exploration evidence. A low confidence diver- gence indicates that the generated code is insufficiently grounded in supporting evidence and warrants inspection. 2.2.3 Semantic Isolation. Unlike traditional transactions that mainly isolate conflicting data accesses, agentic transactions require isola- tion over semantic dependencies among agents, contexts, workspaces, and operations. We consider two levels of isolation: agent–agent isolation and operation–operation isolation. Agent-Level Isolation. Different dependency structures among sub-agents introduce distinct coordination requirements, motivat- ing adaptive isolation strategies supported by agent spawning tools. We formulate isolation selection as a semantic parameter tuning problem, where isolation policies (e.g., access constraints, branching strategies, communication intervals, and termination conditions) are determined based on sub-task semantics and dependencies. This enables learning-based optimization of isolation policies, where a dedicated LLM can be fine-tuned to predict suitable configura- tions for different tasks, analogous to LLM-based database knob tuning [12]. Specifically,(푖)Independent sub-agents address seman- tically disjoint sub-tasks (e.g., summarizing large collections of independent documents), where each sub-agent operates on an 4 exclusive subset of resources with isolated permissions and fully parallel execution.(푖)Collaborative sub-agents jointly construct a shared artifact (e.g., soft engineering involving coordinated code evolution and integration over a shared codebase), where agents maintain independent workspace branches, periodically synchro- nize intermediate results through structured context exchange, and merge changes using a Git-like workflow.(푖)Competitive sub- agents explore alternative hypotheses or solution strategies (e.g., conducting in-depth research by analyzing related literature, vali- dating claims, and synthesizing evidence), where each agent exe- cutes in an isolated virtual environment (e.g., Docker) and the final result is selected from the most promising trajectory. Efficiency can be further improved through copy-on-write initialization and early termination of under-performing branches. Operation-Level Isolation. At the operation level, the skill hub enforces execution isolation through effect annotations and infer- ence, versioned workspaces, snapshot-based execution, and opti- mistic validation, preventing failed or conflicting operations from contaminating shared states. 2.2.4 Semantic Durability. We provide semantic durability through (푖)transaction-aware semantic state management during execution, and(푖) persistent execution tracing and recovery. Transaction-Aware Semantic State Management. Unlike tradi- tional databases that maintain explicit structured states, AI systems operate over evolving semantic states generated from interactions, workspace updates, tool executions, and intermediate artifacts. Pre- serving these states is critical for downstream reasoning, but grow- ing interaction histories quickly exceed finite context windows. Existing approaches typically rely on step-wise LLM summariza- tion to compress interaction histories. However, this process often fails to preserve transaction-level semantic structure, either over- compressing critical information or retaining irrelevant step-level details that are not useful for downstream reasoning. To address this challenge, we propose a transaction-aware evolving memory that maintains semantic states throughout the transaction lifecycle. The memory evolves as a knowledge graph, with insertion, merging, splitting, and deletion operations performed by a specialized LLM. Training supervision can be automatically derived from agent tra- jectories, where information referenced by future execution steps serves as a signal of long-horizon relevance. Execution Tracing and Recovery. Beyond maintaining semantic states during execution, we preserve durable execution histories to support auditing and recovery. Our append-only workspace records provenance information, LLM interactions, tool invocations, and versioned artifacts throughout the transaction lifecycle. These traces enable faithful reconstruction of execution environments, diagnosis of failures, and version-aware failure recovery [9]. 3 EXPERIMENTS 3.1 Experimental Setup All experiments are conducted on a Linux server with 256GB RAM, Intel(R) Xeon(R) Silver 4110 CPU @ 2.10GHz CPU, and NVIDIA GeForce RTX 2080 Ti. Although agentic transactions represent a broader concept, we first validate our ACID-compliant data agent system as an initial proof of effectiveness. Dataset. We use KramaBench [15], a representative benchmark for data agents. It contains 104 natural language tasks over 1,700 real- world data files collected from 24 data sources across 6 domains. Each task specifies a data science objective, requires reasoning over heterogeneous datasets, and involves multi-step workflows. Evaluated Methods. We evaluate state-of-the-art LLMs, including Qwen3.5-397B-A17B [6] and GLM-5.2 [7], provided by the Bail- ian platform [2]. We use default temperatures. We evaluate three representative data-agent harnesses:(푖)Claude Code [4], a general- purpose ReAct-style harness with long-horizon planning, environ- ment interaction, and context management;(푖) ACID-Agent, using a local Qwen3-0.6B [5] for confidence estimation since API-based LLMs lack token probabilities. We set the maximum number of se- mantic units to 20, retain up to 15 historical units, and allow 2 retries per unit. Exploration uses an adaptive budget of 1–4 rounds, de- creasing by one round every two units, and terminates early when confidence divergence exceeds 0.45. Retries are triggered when decision confidence divergence is below 0.25 or the maximum code- span confidence divergence is below 0.50;(푖)DA-Agent [13], a data science agent with Bash, Python, and SQL tools for reactive exe- cution with feedback, serving as an ablation variant ofACID-Agent that removes ACID designs. Evaluation Metrics. We evaluate agents from three perspectives: task quality, execution efficiency, and result consistency. Task qual- ity is measured by the benchmark score, while efficiency is eval- uated by trajectory-level statistics, including coding steps, token consumption, and execution cost. Consistency is measured by the square root of the average per-task variance across multiple runs. 3.2 Main Results We evaluateACID-Agenton KramaBench from two perspectives: overall performance and execution consistency. We measure task scores and quantify consistency using the average per-task variance across three independent runs. Overall Evaluation. As shown in Table 2,ACID-Agentconsis- tently achieves higher overall scores than Claude Code across dif- ferent LLM backbones, with improvements observed in most do- mains. Powered by Qwen3.5-197B-A17B,ACID-Agentoutperforms Claude Code by 10.6% in overall score. Moreover,ACID-Agentwith Qwen3.5-397B-A17B even surpasses Claude Code with the larger GLM-5.2 backbone, demonstrating the effectiveness of our harness design beyond model scaling. This improvement comes at the cost of additional code steps and token consumption, mainly due to exploration and retry mechanisms. The results demonstrate that leveraging a lightweight local model (Qwen3-0.6B) for consistency validation effectively complements much stronger backbone LLMs. Consistency Evaluation. As shown in Table 3,ACID-Agentachieves lower task-level score variation than Claude Code, indicating that confidence-guided exploration and validation can mitigate the non- deterministic deviations from transactional semantics. 3.3 Ablation Study The ablation results are shown in Table 4.(푖)Semantic Transaction Unit.ACID-Agentoutperforms DA-Agent, demonstrating the effec- tiveness of exploration-execution-validation cycles compared with 5 Table 2: Scores (%) and Trajectory-level Metrics on KramaBench.➀=Qwen3.5-397B-A17B,➁=GLM-5.2. Harness LLMScore Domain Scores #Code Steps #Tokens (K) Cost ($) ArchaeologyAstronomyBiomedicalEnvironmentLegalWildfire Claude Code ➀ Qwen64.041.754.244.470.273.371.79.44050.08 ➁ GLM74.250.054.255.690.080.084.28.82890.12 ACID-Agent ➀ Qwen74.641.758.355.690.083.383.722.83480.10 ➁ GLM 77.450.058.377.895.080.083.122.53670.61 Table 3: Consistency of Agent Performance Across Three Runs on the Environment Domain of KramaBench (mean± √︁ avg(Var)). All agents are based on Qwen3.5-397B-A17B. Data AgentScore#Code Steps #Tokens (K) Cost ($) Claude Code63.9± 30.98.5± 2.9372± 161 0.07± 0.03 ACID-Agent 88.9± 18.625.1± 9.8421± 2000.13± 0.06 Table 4: Ablation Study on the Environment Domain of Kram- aBench. All agents are based on Qwen3.5-397B-A17B. Data Agent Score #Code Steps #Tokens (K) Cost ($) DA-Agent65.28.5620.01 Claude Code (3-Majority) 75.225.611210.21 ACID-Agent (No-Isolation) 78.320.13330.10 ACID-Agent90.025.54440.13 conventional ReAct-style execution.(푖)Failed Step Isolation. We remove the isolation mechanism for failed steps, allowing interme- diate failures to directly update the workspace and context memory. This variant reduces the score by 11.7%, demonstrating that prop- agating failed states can contaminate subsequent execution.(푖) Effect of More Tokens.ACID-Agentoutperforms majority-voting Claude Code across three runs with fewer tokens. This indicates that the improvement does not come from increased inference budgets, but from the ACID-inspired harness design. 4 OPEN PROBLEMS Beyond ACID-compliant data agents, building ACID-compliant general-purpose agentic systems raises several open research ques- tions. For atomicity, how can we build scalable skill ecosystems with executable semantics, quality assurance, and safety guarantees that support reliable skill composition and evolution? For consis- tency, how can we ensure reliable reasoning and stable execu- tion across runs through new architectures, benchmarks, model alignment techniques, execution harnesses, machine-checkable con- tracts, and typed tool interfaces? For isolation, how can multi- agent systems safely coordinate access to shared contexts, tools, artifacts, and semantic states? Addressing this challenge requires transactional abstractions and integrated database–LLM serving mechanisms for managing context, ownership, and conflicts [3,14]. For durability, how can we turn agent memory into systematic in- frastructure that supports transactional state management, failure recovery, and persistent evolution for lifelong agents? REFERENCES [1] 2026. Agent Skills - Claude API Docs.Retrieved July 11, 2026 from https: //platform.claude.com/docs/en/agents-and-tools/agent-skills/overview [2]2026. Bailian Console of the Large Model Service Platform. Retrieved July 11, 2026 from https://bailian.console.alibabacloud.com/ [3]2026. oceanbase/seekdb: The AI-Native Search Database. Best for agent storage, it unifies vector, text, structured, and semi-structured data into a single engine. This all-in-one database makes agents smarter, easier to run, and more stable. Retrieved July 14, 2026 from https://github.com/oceanbase/seekdb [4]2026. Overview - Claude Code Docs. Retrieved July 11, 2026 from https://code. claude.com/docs/en/overview [5]2026. Qwen/Qwen3-0.6B· Hugging Face. Retrieved July 14, 2026 from https: //huggingface.co/Qwen/Qwen3-0.6B [6] 2026. Qwen/Qwen3.5-397B-A17B· Hugging Face. Retrieved July 11, 2026 from https://huggingface.co/Qwen/Qwen3.5-397B-A17B [7]2026. zai-org/GLM-5.2· Hugging Face.Retrieved July 11, 2026 from https: //huggingface.co/zai-org/GLM-5.2 [8] Edward Y Chang and Longling Geng. 2025. SagaLLM: Context Management, Validation, and Transaction Guarantees for Multi-Agent LLM Planning. VLDB 18, 12 (2025), 4874–4886. [9]Yunpeng Dong, Jingkai He, Shiqi Liu, Yuze Hou, Dong Du, Zhonghu Xu, Si Yu, Baochuan Yang, Yubin Xia, and Haibo Chen. 2026. DeltaBox: Scaling Stateful AI Agents with Millisecond-Level Sandbox Checkpoint/Rollback. arXiv preprint arXiv:2605.22781 (2026). [10]Theo Härder and Andreas Reuter. 1983. Principles of Transaction-Oriented Database Recovery. ACM Comput. Surv. 15, 4 (1983), 287–317. [11]Lei Huang, Weijiang Yu, Weitao Ma, Weihong Zhong, Zhangyin Feng, Haotian Wang, Qianglong Chen, Weihua Peng, Xiaocheng Feng, Bing Qin, and Ting Liu. 2025. A Survey on Hallucination in Large Language Models: Principles, Taxonomy, Challenges, and Open Questions. ACM Trans. Inf. Syst. 43, 2 (2025), 42:1–42:55. [12]Xinmei Huang, Haoyang Li, Jing Zhang, Xinxin Zhao, Zhiming Yao, Yiyan Li, Tieying Zhang, Jianjun Chen, Hong Chen, and Cuiping Li. 2025. E2ETune: End- to-End Knob Tuning via Fine-tuned Generative Language Model. VLDB 18, 13 (2025), 5540–5554. [13]Yiming Huang, Jianwen Luo, Yan Yu, Yitong Zhang, Fangyu Lei, Yifan Wei, Shizhu He, Lifu Huang, Xiao Liu, Jun Zhao, et al.2024. DA-Code: Agent Data Science Code Generation Benchmark for Large Language Models. In EMNLP. 13487–13521. [14] Hao Kang, Ziyang li, Weili Xu, Xinyu Yang, Yinfang Chen, Junxiong Wang, Beidi Chen, Tushar Krishna, Chenfeng Xu, and Simran Arora. 2026. ThunderAgent: A Fast, Simple, and Program-Aware Agentic Inference System. In ICML. [15]Eugenie Lai, Gerardo Vitagliano, Ziyu Zhang, Om Chabra, Sivaprasad Sudhir, Anna Zeng, Anton A Zabreyko, Chenning Li, Ferdi Kossmann, Jialin Ding, et al. 2025. Kramabench: A benchmark for ai systems on data-to-insight pipelines over data lakes. arXiv preprint arXiv:2506.06541 (2025). [16] Zhiyu Li, Shichao Song, Hanyu Wang, Simin Niu, Ding Chen, Jiawei Yang, Chenyang Xi, Huayi Lai, Jihao Zhao, Yezhaohui Wang, Junpeng Ren, Zehao Lin, Jiahao Huo, Tianyi Chen, Kai Chen, Kehang Li, Zhiqiang Yin, Qingchen Yu, Bo Tang, Hongkang Yang, Zhi-Qin John Xu, and Feiyu Xiong. 2025. MemOS: An Operating System for Memory-Augmented Generation (MAG) in Large Language Models. CoRR abs/2505.22101 (2025). [17] Bardia Mohammadi, Nearchos Potamitis, Lars Klein, Akhil Arora, and Laurent Bindschaedler. 2026. Atomix: Timely, transactional tool use for reliable agentic workflows. arXiv preprint arXiv:2602.14849 (2026). [18]Zhaoyan Sun, Jiayi Wang, Xinyang Zhao, Jiachi Wang, and Guoliang Li. 2025. Data Agent: A Holistic Architecture for Orchestrating Data+AI Ecosystems. CoRR abs/2507.01599 (2025). [19]Zhaoyan Sun, Shan Zhong, Daizhou Wen, Jiaxing Han, Guoliang Li, Ying Yan, Peng Zhang, Yu Su, Xiang Qi, Baolin Sun, et al.2026. AgenticDataBench: A Comprehensive Benchmark for Data Agents. arXiv preprint arXiv:2607.01647. [20]Zhaoyan Sun, Xuanhe Zhou, Guoliang Li, Xiang Yu, Jianhua Feng, and Yong Zhang. 2025. R-Bot: An LLM-Based Query Rewrite System. VLDB 18, 12 (2025), 5031–5044. [21]Zhaoyan Sun, Xuanhe Zhou, Jianming Wu, Wei Zhou, and Guoliang Li. 2025. D-Bot: An LLM-Powered DBA Copilot. In SIGMOD Companion. 235–238. [22]Kimi Team. 2026. Kimi K2.5: Visual Agentic Intelligence. CoRR abs/2602.02276. [23]Xuanhe Zhou, Chengliang Chai, Guoliang Li, and Ji Sun. 2022. Database Meets Artificial Intelligence: A Survey. TKDE 34, 3 (2022), 1096–1116. [24] Xuanhe Zhou, Guoliang Li, Zhaoyan Sun, Zhiyuan Liu, Weize Chen, Jianming Wu, Jiesi Liu, Ruohang Feng, and Guoyang Zeng. 2024. D-Bot: Database Diagnosis System using Large Language Models. VLDB 17, 10 (2024), 2514–2527. [25]Xuanhe Zhou, Zhaoyan Sun, and Guoliang Li. 2024. Db-gpt: Large language model meets database. Data Science and Engineering 9, 1 (2024), 102–111. 6