Tsinghua reboots ACID transactions for LLM agents; a 0.6B confidence model adds 10.6 points over Claude Code

Agentic Transaction: Towards ACID-Compliant Agent Systems

Zhaoyan Sun, Xiaoxiao Wang, Guoliang Li

cs.DB, cs.AI, cs.CL, cs.LG

2026-08-14

A Tsinghua database group reinterprets ACID as four semantic guarantees for agent execution (commit-or-retry cycles, confidence-divergence validation, dependency-aware isolation, transactional memory) and beats Claude Code by 10.6% on KramaBench with the same backbone, while a local 0.6B model supplies the confidence signal.

What problem this solves

Once agents stopped being chat assistants and started running dozens of steps over real environments, they hit problems databases solved four decades ago: reliable execution, consistent outcomes, safe concurrency, recoverable state. In practice, one agent running the same task three times can swing 30 points; a failed step poisons later reasoning with dirty state; growing context eventually overflows the window and crude summarization buries what mattered. Today this is handled by bespoke engineering patches, with no shared abstraction.

The proposal: import ACID semantics, invented for databases in the 1970s, and rewrite them for agent execution.

Method

An agentic transaction is a bounded sequence of model-environment interactions that commits only if validation passes, otherwise rolls back or compensates. Each classic property maps to a mechanism:

• Semantic atomicity: the trajectory is cut into exploration-execution-validation cycles, each a commit unit. Failed steps have their intermediate contexts isolated from memory and their workspace updates dropped. An offline skill hub packages repos and workflows as reusable skills with idempotency keys, write-ahead logs, and automatic compensation
• Semantic consistency: confidence validation in place of assertions. LLM confidence is the exponential of the average token-level log probability. Two concrete signals: decision confidence divergence (decisions considered during exploration vs. decisions actually executed in code; below 0.25 triggers retry) and code confidence divergence (if confidence on decision-relevant code spans doesn't rise with exploration evidence, the code isn't grounded in it). API models don't expose token probabilities, so a locally served Qwen3-0.6B does the measuring
• Semantic isolation: adaptive strategy by dependency structure — independent sub-agents take exclusive resources and run fully parallel; collaborative ones use Git-like branching and merging; competitive ones each get a Docker environment with the best trajectory winning
• Semantic durability: memory maintained as a knowledge graph by a specialized LLM doing insert, merge, split, delete; an append-only workspace records provenance, invocations, and versioned artifacts for audit and version-aware recovery

The architecture has a pragmatic split: strong API models do the reasoning and coding while a cheap local model measures how trustworthy the output is.

Results

KramaBench: 104 natural-language tasks over 1,700 real data files across 6 domains.

Same backbone, ACID-Agent beats Claude Code by 10.6 points, and the smaller-backbone ACID-Agent overtakes the larger-backbone Claude Code, so the gain comes from harness design rather than model scale, at the price of more code steps and tokens from exploration and retry.

Consistency is the more striking number. Across three independent runs on the Environment domain, Claude Code scores 63.9 ± 30.9 while ACID-Agent scores 88.9 ± 18.6, variance roughly halved. Removing failed-step isolation drops the ablation from 90.0 to 78.3 (-11.7). Against three-run majority-vote Claude Code (75.2 at 1121K tokens, $0.21), ACID-Agent hits 90.0 on 444K tokens and $0.13, so the gain is not bought with inference budget.

Why it matters

For agent-infrastructure teams this offers a ready conceptual frame: define transaction semantics once instead of hand-rolling retries and state management per project. The confidence-divergence signal is the most portable piece: a 0.6B local model gives any API model a self-doubt mechanism at near-zero cost, transplantable to data or coding agents. Run-to-run inconsistency finally has both a metric (per-task variance) and a treatment.

Keep the positioning in view: this is a first validation on data agents only, far from ACID for general-purpose agent systems.

Limitations

The authors call it an initial proof of effectiveness and leave four open problems: scalable skill ecosystems, consistency-oriented benchmarks and alignment, multi-agent coordination over shared context, and transactional memory infrastructure for lifelong agents.

Three more concerns from a close read. The ablation isolates only failed-step isolation, so the individual contribution of confidence validation versus knowledge-graph memory is unmeasured. Consistency numbers cover a single domain out of six. All confidence thresholds (0.25, 0.45, 0.50) are hand-tuned with no evidence they transfer across model families or task types. And mean log probability is itself a contested proxy for certainty in RLHF-trained models.

Terms

• ACID: the four database transaction properties (atomicity, consistency, isolation, durability)
• write-ahead log: persist the intended action before executing it, enabling recovery or undo after a crash
• idempotency key: a unique handle making repeated execution side-effect-free
• ReAct: the classic agent loop alternating reasoning and acting
• KramaBench: a data-agent benchmark pairing natural-language tasks with real heterogeneous data files

Source

• arXiv 2608.13900v1
• PDF
• Hugging Face
• GitHub · https://github.com/TsinghuaDatabaseGroup/ACID-Agent

Related papers

• Strongly universal string hashing at 0.2 cycles per byte beats Rabin-Karp and SAX
• Carnot compiles deep-research queries into inspectable execution graphs users can edit mid-run
• RAG-Stack: Co-Optimizing RAG Quality and Serving Performance Across a Huge Config Space
• TEngineDB-V makes large-k vector search a native OLAP operator, up to 145x faster than StarRocks

All paper explainers