AECP: Artifact-Exclusive Communication Protocol for Multi-Agent Code Generation

Jiaqi Xue; Yanjun Wang; Xiangci Li; Lingbo Mo; Aritra Sengupta; Shweta Garg; Murali Krishna Ramanathan; Myeongsoo Kim

cs.CLOct 5, 2026

AECP: Artifact-Exclusive Communication Protocol for Multi-Agent Code Generation

Authors: Jiaqi Xue, Yanjun Wang, Xiangci Li, Lingbo Mo, Aritra Sengupta, Shweta Garg, Murali Krishna Ramanathan, Myeongsoo Kim

Organizations: University of Central Florida · AWS AI Labs

Abstract

As AI agents increasingly tackle complex repository-level coding tasks, distributing work across multiple agents is a natural way to scale beyond the capabilities of a single agent. To coordinate their interdependent work, these agents share findings and agree on interfaces between modules. However, exchanged information often serves only as context, leaving individual agents to interpret it and incorporate it into subsequent work. Consequently, shared findings may go unused and deviations from interface agreements may go undetected, undermining the reliability and efficiency of collaboration. This motivates moving part of the coordination responsibility from individual agents to the execution harness. To make shared information actionable during execution, we introduce the Artifact-Exclusive Communication Protocol (AECP). AECP requires agents to communicate exclusively through structured artifacts and specifies how the harness processes them. The harness supplies findings when agents access relevant code, screens implementations for mismatches with recorded interface commitments, and requires affected agents to revisit revised agreements. These coordination steps become part of harness execution rather than actions that agents must initiate from prior messages. Across Doc2Repo, NL2Repo, and CodeProjectEval, using closed- and open-source models including Opus-4.8 and DeepSeek-V4-Flash, AECP improves average test pass rate by 28.2% and reduces average wall time by 16.5% relative to an agent team using free-form inter-agent messages. Artifact-exclusive communication also blocks the relay of malicious instructions between agents, reducing how often they reach other agents from 95% to 0% and how often those agents act on them from 40% to 0%.

Figures & tables

Figure 1: Multi-agent coordination and development overhead. (a) Agents interpret exchanged messages and decide how to act on them; shared plans and agreements may be followed, deviated from, or ignored. (b) AECP requires exchanges to pass through structured artifacts, enabling the execution harness to guide agents with shared knowledge and check implementations against recorded agreements. (c) Token and interaction-turn distributions for the natural-language communication baseline across 104 NL2Repo tasks, estimated from LLM-labeled trajectories (Appendix G ).

Figure 2: System overview of AECP. (a) The leader converts project specifications into a module plan and assigns modules to workers based on their dependencies. (b) Workers explore, implement, and test their assigned modules in parallel, sharing findings and interface commitments through artifacts. (c) The execution harness uses Knowledge Artifacts to supply relevant findings at the point of use and Contract Artifacts to support parallel development and screen implementations for mismatches with interface commitments.

Figure 3: Scope-triggered knowledge sharing. Worker A records a reusable finding together with its applicable scope. When Worker B accesses the corresponding code, the harness matches the current scope against stored artifacts and includes the relevant finding in the returned observation, making it available for subsequent reasoning and implementation.

Figure 4: Contract Sharing for parallel development. Worker A declares an interface that the harness exposes as importable stubs for Workers B and C. The harness screens the producer’s completed implementation for static mismatches with the latest contract. When the interface changes, it identifies affected consumers through registered dependencies and requires them to revisit the revised contract before completing their tasks.

Model	Method	Doc2Repo			NL2Repo			CodeProjectEval
Model	Method	Score	Time (s)	Token (M)	Score	Time (s)	Token (M)	Score	Time (s)	Token (M)
Opus -4.8	Single	$0.71_{{\color[rgb]{0.5,0.5,0.5}\pm 0.02}}$	$282_{{\color[rgb]{0.5,0.5,0.5}\pm 83}}$	$7.06_{{\color[rgb]{0.5,0.5,0.5}\pm 1.12}}$	$0.65_{{\color[rgb]{0.5,0.5,0.5}\pm 0.04}}$	$868_{{\color[rgb]{0.5,0.5,0.5}\pm 97}}$	$7.49_{{\color[rgb]{0.5,0.5,0.5}\pm 0.62}}$	$0.41_{{\color[rgb]{0.5,0.5,0.5}\pm 0.05}}$	$894_{{\color[rgb]{0.5,0.5,0.5}\pm 126}}$	$4.89_{{\color[rgb]{0.5,0.5,0.5}\pm 0.29}}$
	Team-Freedom	$0.52_{{\color[rgb]{0.5,0.5,0.5}\pm 0.05}}$	$505_{{\color[rgb]{0.5,0.5,0.5}\pm 146}}$	$8.71_{{\color[rgb]{0.5,0.5,0.5}\pm 0.38}}$	$0.51_{{\color[rgb]{0.5,0.5,0.5}\pm 0.03}}$	$1{,}194_{{\color[rgb]{0.5,0.5,0.5}\pm 71}}$	$6.90_{{\color[rgb]{0.5,0.5,0.5}\pm 1.31}}$	$0.25_{{\color[rgb]{0.5,0.5,0.5}\pm 0.02}}$	$1{,}038_{{\color[rgb]{0.5,0.5,0.5}\pm 94}}$	$5.10_{{\color[rgb]{0.5,0.5,0.5}\pm 0.87}}$
	Team-Integrator	$0.68_{{\color[rgb]{0.5,0.5,0.5}\pm 0.02}}$	$607_{{\color[rgb]{0.5,0.5,0.5}\pm 88}}$	$18.57_{{\color[rgb]{0.5,0.5,0.5}\pm 1.57}}$	$0.66_{{\color[rgb]{0.5,0.5,0.5}\pm 0.05}}$	$1{,}753_{{\color[rgb]{0.5,0.5,0.5}\pm 119}}$	$10.45_{{\color[rgb]{0.5,0.5,0.5}\pm 0.44}}$	$0.42_{{\color[rgb]{0.5,0.5,0.5}\pm 0.04}}$	$830_{{\color[rgb]{0.5,0.5,0.5}\pm 153}}$	$8.43_{{\color[rgb]{0.5,0.5,0.5}\pm 0.36}}$
	AECP	$0.70_{{\color[rgb]{0.5,0.5,0.5}\pm 0.04}}$	$330_{{\color[rgb]{0.5,0.5,0.5}\pm 76}}$	$8.24_{{\color[rgb]{0.5,0.5,0.5}\pm 0.51}}$	$0.68_{{\color[rgb]{0.5,0.5,0.5}\pm 0.03}}$	$775_{{\color[rgb]{0.5,0.5,0.5}\pm 134}}$	$10.09_{{\color[rgb]{0.5,0.5,0.5}\pm 1.09}}$	$0.44_{{\color[rgb]{0.5,0.5,0.5}\pm 0.03}}$	$871_{{\color[rgb]{0.5,0.5,0.5}\pm 112}}$	$6.72_{{\color[rgb]{0.5,0.5,0.5}\pm 1.24}}$
Opus -4.6	Single	$0.59_{{\color[rgb]{0.5,0.5,0.5}\pm 0.04}}$	$329_{{\color[rgb]{0.5,0.5,0.5}\pm 61}}$	$3.29_{{\color[rgb]{0.5,0.5,0.5}\pm 0.18}}$	$0.62_{{\color[rgb]{0.5,0.5,0.5}\pm 0.05}}$	$1{,}511_{{\color[rgb]{0.5,0.5,0.5}\pm 86}}$	$6.43_{{\color[rgb]{0.5,0.5,0.5}\pm 0.28}}$	$0.31_{{\color[rgb]{0.5,0.5,0.5}\pm 0.05}}$	$1{,}722_{{\color[rgb]{0.5,0.5,0.5}\pm 93}}$	$4.12_{{\color[rgb]{0.5,0.5,0.5}\pm 0.21}}$

Table 1: Main results across five models and three repository-construction benchmarks. Values report mean

\pm

standard deviation over three independent runs, where each run’s value is averaged over the benchmark’s tasks. Higher scores are better; lower time and token usage are better.

Method	AWS Strands			mini-SWE
Method	Score	Time	Token	Score	Time	Token
Single	$0.65$	$868$	$7.49$	$0.65$	$990$	$12.18$
Team-Freedom	$0.51$	$1{,}194$	$6.90$	$0.54$	$1{,}646$	$13.66$
Team-Integrator	$0.66$	$1{,}753$	$10.45$	$0.66$	$2{,}614$	$15.36$
AECP	$0.68$	$775$	$10.09$	$0.69$	$1{,}056$	$15.32$

Table 2: Cross-scaffold results on NL2Repo. Time in seconds; tokens in millions.

Figure 5: Efficiency gains and task difficulty. (a) Distribution of per-task orchestrator-token usage for Team-Integrator and AECP. (b) Team-token usage as Knowledge Sharing and then Contract Sharing are added to Team-Integrator . Action-category shares are normalized to the original Team-Integrator token total. (c) Wall time, total output tokens, and score by task difficulty for a single run of Opus-4.6 on NL2Repo.

Adaptive subset	Selected $N$		Forced $N=3$
Adaptive subset	Time (s)	Score	Time (s)	Score
$N=1$ (39 tasks)	$403.2$	$0.82$	$748.6$	$0.82$
$N=2$ (17 tasks)	$572.9$	$0.66$	$629.2$	$0.63$
$N=3$ (45 tasks)	$849.6$	$0.54$	$867.2$	$0.54$
$N>3$ (3 tasks)	$926.8$	$0.52$	$931.4$	$0.52$
All 104 tasks	$639.2$	$0.66$	$785.7$	$0.66$

Table 3: Matched adaptive versus fixed team sizing on 104 tasks. Each row compares the same task subset using the selected

N

and forced

N=3

Metric	Team-Freedom	AECP
Reach	$19/20$ ( $95\%$ )	$0/20$ ( $0\%$ )
Adoption	$8/20$ ( $40\%$ )	$0/20$ ( $0\%$ )

Table 4: Propagation of malicious instructions from a compromised worker across 20 attack cases.

Appendix figures & tables4 assets

Supplementary material from the paper’s appendix.

Appendix

Figure 6: From (a) a single general-purpose agent that uses tools and task-specific sub-agents to (b) an agent team composed of multiple such agents. Each teammate retains the capabilities shown in (a), while maintaining its own execution trajectory and coordinating changes to a common project.

Construct	Treatment
Default values	Parameter names, order, and keyword-only parameters are compared; default values are not.
args / *kwargs	Abstain on the call shape.
Missing annotations	Abstain on the type comparison.
Function decorators	The signature is read from the definition as written.
@overload	The final, implementing definition is checked.
@dataclass without init	The constructor is derived from the annotated fields.

Appendix

Table 5: Treatment of Python constructs by the static contract checker.

Method	w/o Adaptive Thinking			w/ Adaptive Thinking
Method	Score	Time (s)	Token (M)	Score	Time (s)	Token (M)	AT Rate
Single	$0.65$	$868$	$7.49$	$0.67$	$885$	$7.80$	$47\%$
Team-Freedom	$0.51$	$1{,}194$	$6.90$	$0.55$	$1{,}528$	$10.70$	$51\%$
Team-Integrator	$0.66$	$1{,}753$	$10.45$	$0.67$	$2{,}103$	$12.64$	$43\%$
AECP	$0.68$	$775$	$10.09$	$0.69$	$961$	$14.32$	$45\%$

Appendix

Table 6: Effect of adaptive thinking on Opus-4.8 performance on NL2Repo. Adaptive-thinking rates are reported as percentages.

Leader	Worker	Score	Time (s)	Cost ($/repo)
DS-V4-Flash	DS-V4-Flash	$0.425$	$1{,}180$	$\$ 0.12$
Opus-4.8	DS-V4-Flash	$0.502$	$1{,}287$	$\$ 0.69$
Opus-4.8	Opus-4.8	$0.680$	$775$	$\$ 2.03$

Appendix

Table 7: Leader–worker model allocation on NL2Repo.

Explore similar work

Jul 30, 2026cs.MA

AgentRadio: Passive Awareness for Long-Horizon Multi-Agent Collaboration

Understanding large codebases is a long-horizon task for Large Language Model (LLM) agents: answering a single question can require building and running the software, tracing execution across files, and synthesizing evidence over tens of minutes. On SWE-Atlas QnA, a benchmark of long-horizon questions over production repositories, a single Claude Code agent (Opus 4.6) resolves only 32.3% of tasks. Dividing the work among agents with clean contexts mitigates this limitation. However, the subtasks of code comprehension are interdependent. One agent's findings can rewrite another's task, so agents must coordinate during execution, not only at phase boundaries. Existing multi-agent systems support such exchange only between phases, through staged handoffs or synchronized rounds. Communication and work remain mutually exclusive. A discovery made mid-execution cannot be shared until the next boundary. We present AgentRadio, an asynchronous message-passing layer that equips coding-agent harnesses with three primitives: threads, messages, and waiting for mentions. The last runs as a background task, surfacing teammates' messages without interrupting foreground work, so each agent remains passively aware of its peers and folds new findings into its ongoing task. Under a five-phase protocol of division of labor and negotiation, four agents organized by AgentRadio resolve 62.1% of tasks, 29.8 points above a single agent and above Claude Code with the newer Opus 4.8 (57.2%). Rubric-level analysis shows the gain growing with task difficulty, consistent with mid-course correction as the underlying mechanism. Our code is available at https://github.com/Coral-Protocol/AgentRadio.

Xinxing Ren, Qianbo Zang, Ziyan Wang +4

1Coral AI Labs · 2SnT, Université du Luxembourg · 3King’s College London +1

Coding Agents Collaboration Single-Agent Long-Horizon Task Planning Passive

Ask PDF

May 31, 2026cs.LG

When Parallelism Pays Off: Cohesion-Aware Task Partitioning for Multi-Agent Coding

Multi-agent Large Language Model (LLM) systems offer a way to decompose complex tasks, such as coding, through parallelization and context isolation. However, adding agents in practice introduces inter-agent communication overhead, which incurs extra cost and can sometimes offset the efficiency gains. We formalize multi-agent orchestration as a graph partitioning problem that captures the communication-to-computation trade-off: task decomposition can shorten critical-path computation, but cross-agent dependencies require costly context transfer. We instantiate this view in repository-level software engineering and present Cohesion-aware Coder (Co-Coder), which builds dependency graphs from static analysis, isolates structural hub files, partitions the graph via community detection, and executes the partition with a dependency-aware scheduler. Across 28 real-world tasks on DevEval and CodeProjectEval, Co-Coder advances the Pareto-frontier over sequential and file-based parallel baselines as well as Claude Code with Agent Teams, lifting pass rate by up to 14.0%, achieving up to a 2.10x wall-clock speedup, and reducing API cost by up to 35%, with the largest gains on the most dependency-dense projects. Co-coder demonstrates how cohesion-aware orchestration can make parallel coding agents both theoretically grounded and practically efficient, suggesting a broader design principle for multi-agent systems.

Xu Yang, Lunyiu Nie, Ethan Chandra +3

1The University of Texas at Austin · University of Oxford

Multi-Agent Orchestration Coding Agents Partitioning

Ask PDF

Sep 29, 2026cs.SE

OpenCollab: A Multi-Agent Coding Framework with Programmable Collaboration and Controllable Runtime

Multi-agent coding systems are designed to tackle complex software engineering tasks through collaboration. However, existing evaluations typically assume configured organizations are followed faithfully, whereas reality differs. This behavioral gap, combined with differences in underlying system components, prevents clear attribution of observed gains. To this end, we introduce OpenCollab, a multi-agent coding framework that provides a unified infrastructure for programmable collaboration and controllable runtime. Specifically, OpenCollab unifies organization design, enforces experimental control on a shared runtime, and tracks execution through fine-grained event streams. On this basis, we define Adherence to quantify whether the declared organization is actually realized. Our experiments reveal that agents collaborate very differently across configurations: changing any single dimension shifts Adherence, from 47.2% to as high as 97.2%. Furthermore, extensive agentic coding benchmarks show that a two-coder workflow built on OpenCollab establishes new SOTA performance compared to the mainstream harnesses such as Mini-SWE-agent, Codex CLI, and Claude Code, showing that a well-designed organization can outperform strong existing harnesses, while OpenCollab's single-agent configuration uses the fewest tokens across all evaluated suites. OpenCollab establishes a unified multi-agent infrastructure for easy programmable collaboration and controlled causal evaluation.

Chun-Wah Hsu, Kai Gong, Yu Wu +12

Shanghai Jiao Tong University · University of Cambridge · Nanyang Technological University +4

Collaboration Coding Agents Organizational Research Single-Agent Runtime

Ask PDF