acceptodds
Under review as a conference paper at ICLR 2027

Atxserve: Towards Transaction-Aware Inference Serving for Multiagent Systems

Abstract

Language model agents increasingly collaborate in shared workspaces to solve complex tasks. However, concurrent updates of multi-agents can compromise consistency or invalidate costly inference. A naive approach is to model these operations as database transactions and apply conventional concurrency control. But this direct transfer is poorly matched to agent workloads, since prolonged model inference dominates the interval between read and write operations. Optimistic validation detects conflicts only after expensive inference has been performed, while pessimistic locking can suppress useful concurrency throughout inference. This mismatch creates a fundamental tension between preserving consistency and GPU efficiency. In this paper, we address this mismatch by shifting the optimization focus from state access to model execution. Specifically, we reformulate agent concurrency control as a GPU scheduling problem and introduce Atxserve. Atxserve constructs a conflict graph before model inference, orders conflicting requests, and admits compatible requests together. Admitted requests then bind current snapshots and retain protection through validation and commit. This design avoids inference that would be invalidated by conflicts, and preserves concurrency among non-conflict transactions. To evaluate Atxserve across diverse concurrency scenarios, we develop RMWBench, which emulates multi-agent workloads with controllable conflicts. On workloads based on real-world repositories, aggregate comparisons show that Atxserve improves useful throughput over optimistic concurrency control.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
LLM serving, inference scheduling, multi-agent systems, concurrency control, GPU scheduling

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_BfhjOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

AtxServe is a system designed to deal with wasted work across AI agents working and editing the same shared files. It avoids outdated agent edits that cause GPU time to be spent on a discarded and regenerated version by putting a gatekeeper in front of the infrerence server that tracks conflicts. When requests conflict, they wait. When they do not, multiple non-conflicting requests are admitted at once, starting from the least conflicting ones. The key idea is to decide conflicts before spending any GPU time, thereby allowing to reduce wasted work and achieve better GPU packing. The authors implement AtxServe and demonstrate up to 50% increase in throughput and zero stale or wasted edits.

Critical strengths

(S1) Thank you for the submission. Allowing agents to update shared documents efficiently is a real and important problem in practice. I think asking the question at the serving layer is an interesting (albeit some unconventional) take on the problem.

(S2) The paper is overall well written and is clear about its scope, in particular with respect to declaration requirements and exclusion of external effects.

Critical weaknesses

(W1) I think the paper asks an interesting question: how can a shared serving layer help avoid inference waste on edit conflicts? However, it does not convince that the problem shows up in practice in the form it describes. The authors do not evaluate on real agent frameworks and instead focus on synthetic tasks. Similarly, a number of obvious alternatives are not considered, e.g., merging, prompting again with changed inputs, or using finer-grain blocks. The paper also assumes that the read and write sets predeclared before inference. Hoewver, the experiments replay fixed sets so it is not clear that agents can automatically produce them correctly. Overall, I find the question intriguing, but I am not convinced that serving is the right layer or that the specific problem appears in practice outside of the paper's own limited setup.

(W2) I feel the novelty of the paper is relatively limited compared to the broader area of currency control. Much of the design has direct precedence in distributed systems and database design, such as contention-aware lock scheduling, reordering operations using predeclared sets, conflict graphs, etc. The paper claiming to “reformulate concurrency control as a GPU scheduling problem” is a weird overstatement since vLLM remains unmodified and the proposed solutions run on top of it. Similarly, calling what the system does “transactions” is somewhat confusing as it does not deal with conflicts across the task stages agents go through, i.e., there is no atomicity or isolation for an agentic task. As far as I can tell, the equivalent primitive to AtxServe in databases would be read-modify-write, which is absolutely not equivalent to a transaction.

(W3) The paper's benefits are measured and reported mostly against the wrong baseline. Optimistic concurrency control (OCC) loses because it regenerates stale edits. This mostly comes from the fact that two edits to the same file will conflict even if they touch different locations and the rejected edit is therefore regenerated in full, which means that simple locking beats OCC under contention. However, on simple locking, AtxServe only achieves benefits because it packs request batches better as shown in Table 2. In other words, if the goal is to not waste GPU on stale edits, simple locking is a good enough solution and better batch packing is a distinct contribution that can be completely separated from the locking aspects.

(Minor) The fit is potentially questionable for ICLR. My score does not reflect this, but in the event the paper is not accepted at ICLR, I would advise the authors to consider systems or database venues as a potential resubmission target. I feel they would be a more natural home for this kind of work.

Questions for authors

Please see the critical weaknesses above for context.

(Q1) Can you better support your serving-layer approach, e.g., through an argument or comparisons with alternative designs?

(Q2) Please explain the choice of terminology related to transactions.

(Q3) Are there any benefits beyond better packing when comparing with the right baseline?

3 comments
AuthorsOpenReview ↗

Response to Reviewer Bfhj (1 of 3)

Overall Response

Thank you for recognizing the value of the problem and for your comments on the system's positioning, transaction terminology, baselines, and alternative designs. Our starting point is to use the conflict structure of shared state as a scheduling signal for inference services, coordinating conflicts before main inference while preserving opportunities for compatible requests to execute in parallel. Below, we address these concerns by explaining the design rationale, stage-level protection boundaries, and the incremental gains from conflict-aware scheduling under the same protection mechanisms.

Q1 / W1: Why Inference Admission? Does the Problem Arise in Practice?

Here, the admission layer refers to the decision point before main inference and the information available at that point. For a stage, coordination mechanisms can be grouped as follows.

  • Data-access protection uses locks or similar mechanisms to prevent concurrent modifications to protected shared-state dependencies.
  • Inference admission uses access declarations to select compatible stages and coordinate conflicts before main inference.
  • Commit validation and merging check versions or merge edits after main inference.
  • Recovery after conflicts restores execution through reprompting, repair, or compensation.

Admission is the point at which declarations are available but the GPU cost of main inference has not yet been incurred. Admission decisions can use both the conflict structure, which is available to the state layer but not the engine, and engine state, which is available to the engine but not the state layer. Both constrain the admission decision. AtxServe combines dependency protection with compatible-request selection at this point, allowing conflict information to directly inform inference execution. In the submitted version, this coupling is reflected in tying admission capacity to the engine's sequence slots and expressing the objective in terms of GPU time.

Practical relevance. The answer is yes! Whared-state conflicts have been observed in practical multi-agent collaboration. Anthropic's parallel compiler project (2026) [1] reports frequent merge conflicts and agents overwriting one another's changes, and uses task lock files to coordinate task claims. The ICML 2026 paper Position: Multi-Agent Systems Should Prioritize Concurrency Control [2] further notes that long LLM inference durations amplify anomalies such as stale reads and lost updates, and advocates explicit concurrency control.

End-to-end development task. We added an end-to-end development experiment in Jinja, comprising 30 feature requirements in the same codebase decomposed into 100 acceptance subtasks. Qwen3-14B agents autonomously search the source code, generate access declarations online, edit, and test, with conflicts arising during execution. We evaluate 4–32 workers, with three runs per setting. The Jinja experimental materials and task definitions are available in the anonymous repository [3]. Full results are reported in Table R3-1.

Table R3-1. End-to-end development results in Jinja.

WorkersMethodSubtasks / 100Features / 30E2E (min)
4OCC15.33 ± 4.621.00 ± 0.0048.65 ± 3.59
4CoAgent17.67 ± 3.061.00 ± 1.0071.49 ± 14.10
4PCC-FIFO23.33 ± 6.811.33 ± 1.5348.28 ± 4.08
4AtxServe24.33 ± 7.511.33 ± 0.5846.67 ± 9.07
8OCC20.00 ± 4.583.67 ± 1.1541.15 ± 1.56
8CoAgent15.67 ± 4.933.33 ± 0.5872.80 ± 28.21
8PCC-FIFO25.67 ± 5.514.67 ± 1.1546.79 ± 6.47
8AtxServe26.33 ± 6.035.00 ± 1.7336.21 ± 5.77
16OCC26.33 ± 3.214.00 ± 0.0048.34 ± 4.77
16CoAgent24.33 ± 7.575.33 ± 1.5349.08 ± 5.53
16PCC-FIFO28.33 ± 2.085.00 ± 1.0045.59 ± 4.57
16AtxServe29.00 ± 6.935.00 ± 1.7330.85 ± 3.57
32OCC26.67 ± 3.794.67 ± 1.1539.97 ± 3.55
32CoAgent28.33 ± 1.535.00 ± 1.0046.16 ± 1.44
32PCC-FIFO31.33 ± 3.065.00 ± 1.0032.73 ± 2.14
32AtxServe30.67 ± 1.536.33 ± 0.5824.32 ± 2.29

Table R2-2. OCC conflict rate and token usage on the Jinja end-to-end development workload. Token counts are reported in millions (M).

WorkersOCC conflict rate (%, mean ± SD)OCC tokens (M)AtxServe tokens (M)
412.61 ± 1.689.67 ± 0.5576.19 ± 0.093
824.72 ± 4.3910.52 ± 0.6006.53 ± 0.306
1628.71 ± 1.3712.88 ± 0.8846.69 ± 0.300
3243.63 ± 3.9213.55 ± 0.8067.51 ± 0.324

As concurrency increased from 4 to 32 workers, the OCC conflict rate rose from 12.61% to 43.63%, and OCC token usage increased from 9.67M to 13.55M. Across the four settings, AtxServe used 36.0%–48.1% fewer tokens than OCC, with the largest reduction at 16 workers.

AuthorsOpenReview ↗

Response to Reviewer Bfhj (2 of 3)

We address the alternative designs in three parts.

1. Text merging does not ensure that read dependencies remain valid. Even when patches merge cleanly, the state on which they were generated may have changed. For example, in the Commit0-derived workload, commit 139dc11 reads, through an import, a module modified by a87422f. We therefore consider both textual mergeability and dependency-version validity.

2. Reprompting and repair must be evaluated together with their recovery costs. Repair can preserve unaffected work, but may require additional model calls and tool operations. Our CoAgent/MTPO comparison [4] includes agent-guided repair and inverse tool operations, with recovery costs included in the evaluation. On Commit0-derived (Focused), CoAgent and AtxServe achieve UsefulTP values of 1,063.4 and 1,219.2 ops/GPU-hour, with total input-token counts of 1.073M and 0.782M, respectively. This provides an overall efficiency comparison between coordination before inference and repair after conflicts.

3. Fine-grained protection can be combined with conflict-aware admission. All four methods in the Jinja experiment use the same Python AST region granularity. As the worker count increases from 4 to 32, OCC's conflict rate still rises from 12.61% to 43.63%, indicating that shared-state conflicts require coordination even at this granularity. AtxServe constructs a conflict graph from these declarations to schedule compatible stages concurrently before main inference.

Q2 / W2: Transaction Terminology and Novelty

Transaction terminology and protection boundaries. We use stage transaction to mean one independently committed stage of an agent task. If a later stage aborts, earlier stages remain committed. Within a stage, read–modify–write (RMW) describes the computation. The transaction boundary specifies how its effects become visible: all of the stage’s writes to the managed workspace are published atomically, and an aborted stage publishes none. Under the conditions of Proposition 3, including enforced declarations covering planning and execution dependencies, atomic snapshot binding and publication, and valid grants held from successful binding through commit, the committed history of managed stages is conflict-serializable. Atomicity and isolation are scoped to a single stage; a long-running task proceeds through multiple independently committed stages.

Technical contribution. AtxServe uses predeclared access sets, conflict graphs, and logical protection to coordinate model inference, turning planning dependencies into enforceable admission constraints. The system combines three complementary design choices motivated by inference cost.

  1. Coordinate conflicts before main inference to reduce repeated computation after invalidation. Retries caused by invalidated dependencies consume shared model-service resources again. In the high-contention experiment with 1,024 operations, as concurrency increases from 8 to 32, OCC's runtime rises from 594s to 997s, whereas AtxServe's rises from 592s to 634s (Table 22). These results demonstrate the efficiency benefit of coordination before inference as concurrency scales.
  2. Use conflict structure to select compatible requests and preserve concurrency. In an ablation with reservation disabled and identical declaration resolution, validation, grants, and capacity constraints, minimum-degree selection improves UsefulTP over PCC-FIFO by 4.9% on RMWBench (High) and 12.3% on Commit0-derived (Focused) (Table 11). This ablation isolates the benefit of candidate selection under the same protection mechanism.
  3. Validate planning observations at binding to connect planning with execution. When dependencies change before binding, validation at binding reduces tokens per completed task by 18.9% relative to validation only at commit (Fig. 6d). After successful validation, the grant protects both planning and execution dependencies until commit.
AuthorsOpenReview ↗

Response to Reviewer Bfhj (3 of 3)

Q3 / W3: Are There Benefits Beyond Packing Compared with the Appropriate Baseline?

AtxServe's core contribution is to incorporate shared-state dependencies into inference admission to improve useful inference throughput under consistency constraints. Dependency protection orders stages with declared conflicts, while conflict awareness uses the conflict structure to select compatible requests and order admission.

Comparisons under the same protection mechanisms quantify the scheduling contribution. PCC-FIFO already allows compatible requests to run concurrently and skips blocked requests. Table 11 fixes declaration resolution, binding validation, grants, and capacity settings, and disables reservation, changing only the candidate selection rule. Minimum-degree selection prioritizes stages with fewer conflicts to preserve subsequent opportunities for compatible execution. On RMWBench (High) and Commit0-derived (Focused), random compatible selection improves UsefulTP over PCC-FIFO by 1.1% and 2.1%, whereas minimum-degree selection yields gains of 4.9% and 12.3%. Across all 10 paired repetitions over these two workload settings, AtxServe's UsefulTP exceeds PCC-FIFO's. Within each setting, the mean useful-completion counts are equal and mean token counts differ by less than 1.2% (Table 13; Appendix D.4).

Scheduling gains increase with concurrency. In the high-contention experiment, AtxServe's UsefulTP gain over PCC-FIFO grows from 4.2% to 27.9% as concurrency increases from 8 to 32 (Table 22). The Jinja experiment with online declarations provides a further comparison: at 32 workers, PCC-FIFO and AtxServe have mean E2E runtimes of 32.73 and 24.32 minutes, respectively (Table R3-1).

Shared dependencies can also inform engine-side request priorities. For example, under mixed traffic or limited KV capacity, the current waiting relationships could be used to assign higher request priorities, at submission time, to grant holders blocking multiple stages. Such a scheme could use vLLM's priority scheduling without modifying the engine code. The approach would prioritize requests that block more subsequent work, illustrating the value of connecting state coordination with engine scheduling at the inference-admission point.

Minor Concern: Fit for ICLR

Thank you for this suggestion. ICLR's call for papers explicitly includes infrastructure for learning systems, and LLM-serving work such as Preble [5] was published at ICLR 2025. Our work studies coordination between dependencies arising from agent planning and shared inference resources. The added Jinja experiment further demonstrates end-to-end behavior with online declarations.

We would welcome further discussion of the paper and the opportunity to improve it with your feedback. The relevant changes are marked in blue in the uploaded revised PDF for your reference.

References

[1] Nicholas Carlini. Building a C compiler with a team of parallel Claudes. Anthropic, 2026. URL https://www.anthropic.com/research/building-c-compiler

[2] Xin Yang, Letian Li, Zimo Ji, Terry Jingchen Zhang, and Wenyuan Jiang. Position: Multi-Agent Systems Should Prioritize Concurrency Control. In Proceedings of the 43rd International Conference on Machine Learning, volume 306 of Proceedings of Machine Learning Research, pp. 172725–172740, 2026.

[3] Jinja task definitions. Anonymous supplementary materials. URL https://anonymous.4open.science/r/atxserve-1FDD/data/jinja/Jinja_Feature_Definitions.md

[4] Hongtao Lyu, Dingyan Zhang, Mingyu Wu, Xingda Wei, and Haibo Chen. CoAgent: Concurrency Control for Multi-Agent Systems. arXiv preprint arXiv:2606.15376, 2026.

[5] Vikranth Srivatsa, Zijian He, Reyna Abhyankar, Dongming Li, and Yiying Zhang. Preble: Efficient Distributed Prompt Scheduling for LLM Serving. In International Conference on Learning Representations, 2025.

Reviewer_ZUx2OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

ATXSERVE coordinates shared-workspace access with inference admission for multiagent systems. It uses declared read/write dependencies to select compatible requests, validates planning reads before main inference, and protects dependencies until commit. Implemented around an unchanged vLLM engine, it is evaluated on controlled read-modify-write workloads, repository-derived tasks, and a small source-editing study, showing improved useful throughput and reduced wasted inference under contention.

Critical strengths

The paper identifies an important limitation of conventional concurrency control for multi-agent workloads. It reframes multi-agent concurrency control as a GPU admission control problem.

Critical weaknesses
  1. Limited evidence on the prevalence and impact of conflicts. The evaluation demonstrates the benefits of ATXSERVE under several controlled contention configurations, but it remains unclear how frequently harmful conflicts occur in representative multi-agent workloads.
  2. Insufficient discussion of existing work.The paper does not sufficiently explain how existing approaches to multi-agent concurrency control work or how they differ from ATXSERVE. In particular, CoAgent is mentioned in the evaluation without sufficient background on its design and underlying mechanisms.
Questions for authors
  1. How frequently do harmful conflicts occur in representative multi-agent workloads, and how significantly do they affect system performance?
  2. Could the authors provide more background on existing approaches to multi-agent concurrency control, particularly CoAgent, and clarify how their designs and underlying mechanisms differ from ATXSERVE?
3 comments
AuthorsOpenReview ↗

Response to Reviewer ZUx2 (1 of 2)

Thank you for recognizing the value of this work and for your suggestions. Your feedback has helped us improve the paper and clarify its motivation and technical contributions. We address your two questions below.

W1 / Q1: Conflict Frequency and Performance Impact in Real Multi-Agent Workloads

Practical systems have observed and addressed conflicts between parallel agents' edits. Anthropic's parallel compiler project [1] reports frequent merge conflicts and agents overwriting one another's changes. OpenAI Codex [2] uses worktrees to isolate parallel edits, while the ICML 2026 position paper on concurrency control [3] discusses anomalies such as stale reads and lost updates. We further quantify the performance impact using Commit0-derived workloads. For the same 96 tasks derived from real commits, as conflicts become more concentrated, OCC's mean stale-operation count rises from 9.0 to 49.0 and its abort count from 2.0 to 13.0. AtxServe's UsefulTP gain over OCC increases from 27.0% to 59.6% (Appendix C.3; Table 7).

End-to-End development task. The added Jinja experiment comprises 30 feature requirements in the same codebase, decomposed into 100 acceptance subtasks. Qwen3-14B agents autonomously search the source code, generate access declarations online, edit, and test, with conflicts arising during execution. We evaluate 4, 8, 16, and 32 workers, with three runs per setting; task definitions are provided in [4]. As the worker count increases from 4 to 32, conflict rate rises from 12.6% to 43.6%. At 32 workers, AtxServe and OCC pass 30.67 and 26.67 subtasks, with mean E2E runtimes of 24.32 and 39.97 minutes, respectively. Full results are reported in Tables R2-1 and R2-2.

Table R2-1. End-to-end development results in Jinja.

WorkersMethodSubtasks / 100Features / 30E2E (min)
4OCC15.33 ± 4.621.00 ± 0.0048.65 ± 3.59
4CoAgent17.67 ± 3.061.00 ± 1.0071.49 ± 14.10
4PCC-FIFO23.33 ± 6.811.33 ± 1.5348.28 ± 4.08
4AtxServe24.33 ± 7.511.33 ± 0.5846.67 ± 9.07
8OCC20.00 ± 4.583.67 ± 1.1541.15 ± 1.56
8CoAgent15.67 ± 4.933.33 ± 0.5872.80 ± 28.21
8PCC-FIFO25.67 ± 5.514.67 ± 1.1546.79 ± 6.47
8AtxServe26.33 ± 6.035.00 ± 1.7336.21 ± 5.77
16OCC26.33 ± 3.214.00 ± 0.0048.34 ± 4.77
16CoAgent24.33 ± 7.575.33 ± 1.5349.08 ± 5.53
16PCC-FIFO28.33 ± 2.085.00 ± 1.0045.59 ± 4.57
16AtxServe29.00 ± 6.935.00 ± 1.7330.85 ± 3.57
32OCC26.67 ± 3.794.67 ± 1.1539.97 ± 3.55
32CoAgent28.33 ± 1.535.00 ± 1.0046.16 ± 1.44
32PCC-FIFO31.33 ± 3.065.00 ± 1.0032.73 ± 2.14
32AtxServe30.67 ± 1.536.33 ± 0.5824.32 ± 2.29

Table R2-2. OCC conflict rate and token usage on the Jinja end-to-end development workload. Token counts are reported in millions (M).

WorkersOCC conflict rate (%, mean ± SD)OCC tokens (M)AtxServe tokens (M)
412.61 ± 1.689.67 ± 0.5576.19 ± 0.093
824.72 ± 4.3910.52 ± 0.6006.53 ± 0.306
1628.71 ± 1.3712.88 ± 0.8846.69 ± 0.300
3243.63 ± 3.9213.55 ± 0.8067.51 ± 0.324

As concurrency increased from 4 to 32 workers, the OCC conflict rate rose from 12.61% to 43.63%, and OCC token usage increased from 9.67M to 13.55M. Across the four settings, AtxServe used 36.0%–48.1% fewer tokens than OCC, with the largest reduction at 16 workers.

AuthorsOpenReview ↗

Response to Reviewer ZUx2 (2 of 2)

W2 / Q2: Differences from Existing Methods, Particularly CoAgent

Traditional OCC validates read versions at commit time and retries if validation fails; PCC acquires read/write protection in advance and retains it until commit. Table R2-3 compares methods designed for agents, focusing on their coordination scope and the timing of conflict handling.

Table R2-3. Comparison of existing concurrency coordination methods for agents.

MethodMechanismCoordination scope
SagaLLM [5]Organizes long workflows into verifiable, compensatable steps and maintains application, operation, and dependency state. An independent validation agent checks outputs and dependencies across agents. Upon failure, it performs compensation according to dependencies and replans using the retained context.Validation and recovery across multiple workflow steps
ATCC [6]Targets transactions executed by SQL data agents. Based on execution stages and contention signals, it uses reinforcement learning to choose between optimistic access and upgrading to read/write lock protection.Adaptive access protection for database transactions
CoAgent [7]MTPO fixes the serialization order at startup. Conflict notifications prompt agents to identify affected operations and perform local repairs. The framework undoes and reorders writes using preregistered inverse operations for tools.Speculative execution and local repair under a predefined order

CoAgent preserves unaffected work by using local repair instead of a full retry. AtxServe differs primarily in using stage-level dependencies, including planning observations, to select compatible requests for admission to a shared model service before main inference. We use a conflict graph to schedule compatible stages concurrently, validate planning versions at binding, and protect dependencies with logical grants until commit. Our focus is on incorporating shared-state dependencies into inference admission to improve useful inference throughput under consistency constraints.

The revised PDF has been uploaded, with the added evidence of conflicts in practice and comparisons with existing methods marked in blue. If you have further questions or suggestions about this evidence or how the comparisons are made, we would be happy to discuss them and make the paper's arguments clearer.

References

[1] Nicholas Carlini. Building a C compiler with a team of parallel Claudes. Anthropic, 2026. URL https://www.anthropic.com/research/building-c-compiler

[2] OpenAI. Introducing the Codex app. OpenAI, 2026. URL https://openai.com/index/introducing-the-codex-app/

[3] Xin Yang, Letian Li, Zimo Ji, Terry Jingchen Zhang, and Wenyuan Jiang. Position: Multi-Agent Systems Should Prioritize Concurrency Control. In Proceedings of the 43rd International Conference on Machine Learning, volume 306 of Proceedings of Machine Learning Research, pp. 172725–172740, 2026.

[4] Jinja task definitions. Anonymous supplementary materials. URL https://anonymous.4open.science/r/atxserve-1FDD/data/jinja/Jinja_Feature_Definitions.md

[5] Edward Y. Chang and Longling Geng. SagaLLM: Context Management, Validation, and Transaction Guarantees for Multi-Agent LLM Planning. Proceedings of the VLDB Endowment, 18(12):4874–4886, 2025. doi: 10.14778/3750601.3750611.

[6] Weixing Zhou, Zhiyou Wang, Zeshun Peng, Hetian Chen, Yanfeng Zhang, and Ge Yu. ATCC: Adaptive Concurrency Control for Unforeseen Agentic Transactions. arXiv preprint arXiv:2603.13906, 2026.

[7] Hongtao Lyu, Dingyan Zhang, Mingyu Wu, Xingda Wei, and Haibo Chen. CoAgent: Concurrency Control for Multi-Agent Systems. arXiv preprint arXiv:2606.15376, 2026.

Dear Reviewer ZUx2,

We sincerely thank you again for your thoughtful and detailed comments. As the rebuttal period is drawing to a close, we would be truly grateful if you could share any further thoughts with us. We remain more than happy to discuss any outstanding concerns, and your feedback would mean a great deal to us.

Reviewer_uxJxOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper examines wasted inference in multi-agent systems that share mutable workspaces. When agents work concurrently, some produce updates based on state that has already changed. Optimistic concurrency control (OCC) detects such conflicts after inference has been spent, while arrival-order admission can restrict concurrency even among compatible requests.

The authors introduce AtxServe, which uses declared read and write dependencies to build a conflict graph and coordinate admission before main inference begins. It selects compatible transactions using a minimum-degree heuristic, reserves opportunities for requests that are repeatedly bypassed, and validates planning observations against a snapshot before execution. Logical grants then protect the declared dependencies through commit, without modifying the vLLM scheduler.

The evaluation covers controlled read-modify-write workloads, repository-based tasks, and a smaller source-editing study. Under contention, AtxServe reduces repeated inference and increases useful throughput. On the Qwen3 4B repository workloads, it reports mean improvements of 27.3%–49.5% over OCC.

Critical strengths
  • The paper focuses on a practical challenge for collaborative agents: conflicts over shared files or state can waste substantial inference, even when stale updates are ultimately rejected correctly.
  • The system design is easy to follow. It uses workspace dependencies to inform admission decisions and does so without requiring changes to the serving engine.
  • The protocol gives careful attention to dependencies observed during planning. Checking those observations when binding a snapshot, and protecting planning as well as execution dependencies through commit, addresses an important source of stale work.
Critical weaknesses
  • AtxServe relies on access declarations that are available before main inference and sufficiently precise. The paper considers conservative declarations and dynamic replanning, but most throughput results use fixed declarations. It remains unclear how accurately agents can produce useful declarations in less constrained workflows, and what recovery costs arise when they cannot.
  • The repository experiments are more controlled than the broad framing might imply. They draw on real source context and commit-derived access patterns, but are not a full Commit0 software-development evaluation. The separate source-editing study adds useful evidence, though it is small: only nine of 48 evaluations pass in each setting.
  • The admission policy aims to maximize the number of compatible requests, not directly the amount of useful work completed. In realistic deployments, requests may differ in duration, context size, likelihood of success, and GPU demand, so admitting the largest compatible set may not maximize throughput.
Questions for authors

I find the problem timely and the integration of workspace consistency with inference admission compelling. The results offer good evidence that addressing declared conflicts before expensive inference can improve useful throughput under contention. Overall, I lean toward acceptance.

My main concern is whether realistic agent workflows can provide access declarations that are both useful and dependable. The protocol enforces declared scope and halts execution if an undeclared dependency appears. This creates a tension: broad declarations limit parallelism, whereas narrow ones may trigger replanning and waste already-completed inference. The current experiments explore these issues largely in separate controlled settings. A more direct study of agent-generated declarations would help establish the combined impact.

Two experiments could clarify this point:

  1. Have agents declare access scopes for longer source-editing tasks, then report declaration breadth, scope violations, planning invalidations, repeated inference, and successful-task throughput.
  2. On the same tasks and compute budget, vary declaration granularity and conservativeness. Where feasible, compare file-level protection with finer-grained regions.

These results would help show when pre-inference coordination remains worthwhile after accounting for the uncertainty and expense of planning.

I also have several questions:

  • Could the paper distinguish more explicitly among the repository-based RMW workloads, Commit Focus, and the source-editing evaluation? In particular, which settings require actual code repair and passing tests, and which use repository context with controlled updates and deterministic scoring?
  • How does minimum-degree admission perform when inference durations vary? Preserving the largest set of compatible requests may not maximize completed useful work if context lengths, output lengths, and resource needs differ.
  • Would a duration- or cost-aware compatible scheduler outperform the current heuristic? This would help determine whether conflict degree alone is an adequate proxy for the serving objective.
5 comments
AuthorsOpenReview ↗

Response to Reviewer uxJx (1 of 2)

Thank you for recognizing the value of the problem and the system design. Your suggestions on declaration feasibility, evaluation settings, and admission policies have guided the additional experiments. We respond to each concern below.

W1 / Main Concern: Agent-Generated Access Declarations

Thank you for raising this concern. Broad declarations preserve consistency protection but can reduce compatible concurrency. Agents already generate declarations online in our code-editing experiments. The main throughput comparisons use fixed replay so that all methods face the same tasks and declarations, controlling for experimental noise.

Online end-to-end development tasks. We added an end-to-end development experiment in Jinja, comprising 30 feature requirements decomposed into 100 acceptance subtasks. Qwen3-14B agents autonomously search the source code, generate access declarations online, edit, and test. We evaluate 4, 8, 16, and 32 workers, with three runs per setting, and report means and sample standard deviations for subtask- and feature-level test passes and end-to-end runtime. Task definitions are provided in the anonymous materials [1].

Table R1-1. Declaration invalidations and scope violations (32 workers).

DeclarationMethodDeclarationsViolations / declarationsRead / write violationsE2E (min)
fileAtxServe3933.3/393 = 0.84%0 / 3.332.32 ± 3.11
regionAtxServe40338.7/403 = 9.60%2.7 / 3624.32 ± 2.29

Trade-offs in declaration granularity. File-level protection covers an entire file. Region-level protection uses the Python AST to identify function blocks, such as src/jinja2/filters.py::do_groupby, allowing different functions in the same file to be declared and protected separately. The violations in the table are accesses outside the declared scope that are detected and blocked at runtime, followed by replanning to adjust the scope. Region-level protection has a higher ratio of violation events to declarations (9.60% versus 0.84%), but reduces mean end-to-end runtime from 32.32 minutes under file-level protection to 24.32 minutes, a 24.8% reduction. Except for this granularity comparison, all four methods in the subsequent Jinja experiments use the same AST region granularity.

Table R1-2. End-to-end development results in Jinja.

WorkersMethodSubtasks / 100Features / 30E2E (min)UsefulTP (txn/h)
4OCC15.33 ± 4.621.00 ± 0.0048.65 ± 3.59486.29 ± 31.25
4CoAgent17.67 ± 3.061.00 ± 1.0071.49 ± 14.10327.07 ± 26.84
4PCC-FIFO23.33 ± 6.811.33 ± 1.5348.28 ± 4.08470.63 ± 31.94
4AtxServe24.33 ± 7.511.33 ± 0.5846.67 ± 9.07494.58 ± 43.56
8OCC20.00 ± 4.583.67 ± 1.1541.15 ± 1.56576.38 ± 35.77
8CoAgent15.67 ± 4.933.33 ± 0.5872.80 ± 28.21324.73 ± 36.12
8PCC-FIFO25.67 ± 5.514.67 ± 1.1546.79 ± 6.47490.75 ± 44.12
8AtxServe26.33 ± 6.035.00 ± 1.7336.21 ± 5.77664.95 ± 55.27
16OCC26.33 ± 3.214.00 ± 0.0048.34 ± 4.77461.36 ± 33.09
16CoAgent24.33 ± 7.575.33 ± 1.5349.08 ± 5.53474.33 ± 28.44
16PCC-FIFO28.33 ± 2.085.00 ± 1.0045.59 ± 4.57501.43 ± 44.12
16AtxServe29.00 ± 6.935.00 ± 1.7330.85 ± 3.57763.76 ± 48.54
32OCC26.67 ± 3.794.67 ± 1.1539.97 ± 3.55576.88 ± 51.34
32CoAgent28.33 ± 1.535.00 ± 1.0046.16 ± 1.44519.02 ± 63.44
32PCC-FIFO31.33 ± 3.065.00 ± 1.0032.73 ± 2.14727.28 ± 69.65
32AtxServe30.67 ± 1.536.33 ± 0.5824.32 ± 2.29943.17 ± 53.69

Dividing mean test-pass counts by mean E2E runtime, at 32 workers, AtxServe and PCC-FIFO achieve 75.7 and 57.4 subtask passes per hour, respectively, and 15.6 and 9.2 feature-level passes per hour.

Table R1-3. Mean conflict rates at different worker counts.

WorkersMean conflict rate (%, mean ± SD)
412.61 ± 1.68
824.72 ± 4.39
1628.71 ± 1.37
3243.63 ± 3.92

References

[1] Jinja task definitions. Anonymous supplementary materials. URL https://anonymous.4open.science/r/atxserve-1FDD/data/jinja/Jinja_Feature_Definitions.md

AuthorsOpenReview ↗

Response to Reviewer uxJx (2 of 2)

W2 / Q1: Distinguishing the Evaluation Settings

Thank you for this suggestion. The following table summarizes the main evaluation settings in the revised manuscript, distinguishing how declarations are obtained and how success is determined.

Table R1-4. Comparison of evaluation settings.

SettingSource context and conflict structureDeclarationsCode repair and passing tests required?
RMWBench controlled workload (Fig. 5a, Fig. 7, Table 3)Synthetic blocks; controlled WW / RW ratiosFixed replayNo; controlled updates and deterministic scoring
Commit0-derived (Dispersed / Mixed / Focused)Real source code and historical commit dependencies; different contention levelsFixed replayNo; controlled updates and deterministic scoring
Jinja end-to-end developmentRepository at a fixed revision; conflicts arise naturally from tasksGenerated online; replanning supportedYes; task tests and publication checks

RMWBench and Commit0-derived workloads use fixed declarations and controlled updates, with deterministic scoring to measure the efficiency of useful commits. Jinja requires agents to search, declare dependencies, edit code, and run tests online; development outcomes are assessed through subtask- and feature-level test passes. The earlier small-scale code-editing study further examines planning-dependency validation and recovery costs.

W3 / Q2 / Q3: Heterogeneous Durations and Cost-Aware Scheduling

Thank you for your suggestions on heterogeneous durations and cost-aware scheduling.

SJF comparison. We use the execution request's input-token count as a duration proxy and compare SJF (Shortest Job First) ordering with conflict-degree ordering. This comparison is separate from the main experiment in Table R1-2, with three runs per policy at 32 workers. The table reports mean agent runtime and feature-level test passes as means ± sample standard deviations.

Table R1-5. SJF versus conflict-degree ordering (32 workers).

MetricAtxServe-SJFAtxServe-Conflict
Mean agent runtime (min)29.63 ± 3.3324.13 ± 3.05
Feature-level test passes6.33 ± 0.586.00 ± 1.00

Conflict-degree ordering has a shorter mean agent runtime. Across the three seeds, the Spearman correlations between input length and stage duration are 0.202, 0.093, and 0.145, indicating that the first request's input length is a weak proxy for stage duration.

Analysis of the admission policy. As a theoretical complement, Appendix B.1 provides a completion-time guarantee for maximal compatible admission under unequal durations, assuming a fixed conflict graph and schedule-independent durations, among other conditions (Eq. (9)). The incremental benefit of minimum-degree selection is measured by a matched ablation. On RMWBench (High) and Commit0-derived (Focused), random compatible selection improves throughput over PCC-FIFO by approximately 1–2%, whereas minimum-degree selection yields gains of 4.9% and 12.3%, respectively (Table 11).

Extension to cost-aware scheduling. The framework can also incorporate duration estimates by adjusting the candidate selection key while retaining compatibility checks and dependency protection. Combining more accurate duration predictions with transaction-aware scheduling is a valuable direction for future work, but lies beyond the scope of this paper. The additional experiments and related discussion have been added to Section 5.6 and Appendix H of the revised manuscript.

Thank you for your detailed suggestions on access declarations, evaluation settings, and scheduling policies. We have uploaded the revised PDF, with the experimental updates and related revisions marked in blue, and would be happy to continue the discussion to further improve the paper.

Dear Reviewer uxJx,

We sincerely thank you again for your thoughtful and detailed comments. As the rebuttal period is drawing to a close, we would be truly grateful if you could share any further thoughts with us. We remain more than happy to discuss any outstanding concerns, and your feedback would mean a great deal to us.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

Thank the reviewers for your assessment and suggestions. Our central idea is to use shared-state conflict structure to guide inference admission. AtxServe coordinates conflicts before main inference and allows compatible requests to run concurrently. The reviewers recognize the practical importance of the problem and find the serving-layer perspective interesting. We have added experiments and clarifications in response to their questions.

Regarding practical relevance, Anthropic's parallel compiler project reports frequent merge conflicts and cases where agents overwrite one another's changes. An ICML 2026 position paper also discusses shared-state concurrency anomalies. Our new Jinja end-to-end study includes 30 feature requirements decomposed into 100 acceptance subtasks. We evaluate 4–32 workers, with three runs per setting. Agents autonomously search the code, generate access declarations online, edit, and test. conflict rate rises from 12.6% to 43.6% as workers increase from 4 to 32. At 32 workers, AtxServe and PCC-FIFO use the same AST region granularity. AtxServe reduces mean end-to-end runtime from 32.73 to 24.32 minutes, relative to PCC-FIFO. The revision clarifies stage-level protection boundaries and compares the mechanisms of CoAgent and related methods. The expanded Discussion presents cost-aware admission and dynamic declaration refinement as future directions. These directions highlight the potential of using shared-state dependencies in inference scheduling for heterogeneous requests and long workflows.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.