acceptodds
Under review as a conference paper at ICLR 2027

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

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%.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Multi-agent System, Coding Agent, LLM, Agent

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_rvBWOpenReview ↗
Rating
2
Confidence
3
Informativeness
2(+1)
Presentation
3
Soundness
2
Read review
Paper summary

The paper investigates how multiple coding agents coordinate when they build a repository together. This paper proposes AECP, a protocol in which agents communicate only through structured artifacts that the execution harness acts on. Evaluated on three Python benchmarks, AECP improves average test pass rate by 28.2%, with reduced average wall time.

Critical strengths
  1. AECP is a concrete and checkable design. Instead of relying on agents to act on messages, AECP defines explicit rules triggered by tool calls.

  2. Evaluation shows consistent gains over a single agent. AECP beats Single in 14 of 15 settings and matches or beats Team-Integrator in all 15 while being faster than both team baselines. The leader-worker allocation study and adaptive team sizing give practical findings on when a team is worth its cost.

Critical weaknesses
  1. The experiments do not show which parts of AECP improve quality, and the main comparison is against a weak baseline.

The controlled baseline is weak. Team-Freedom is presented as "the controlled comparison for AECP as a whole". However, it scores below Single in 12 of 15 settings, and sometimes far below. For example, for Opus-4.8, it scores 0.25 vs. 0.41 on CodeProjectEval and 0.52 vs. 0.71 on Doc2Repo. A team that does much worse than one agent with the same model suggests a weak implementation, for example, uncontrolled concurrent edits in the shared workspace. So the 28.2% in the abstract mostly measures that weakness.

There are also smaller gains against the other baselines. The more relevant gains are +0.050 over Single and +0.041 over Team-Integrator. The second is at most 0.02 in 9 of 15 settings and is driven by GLM-5.2, where Team-Integrator collapses (0.42 and 0.35).

The ablation study on quality is also missing. RQ2 adds the mechanisms one at a time only for token usage, on one model and one benchmark. Its first step also bundles the shared workspace with Knowledge Sharing. However, this paper never shows how much of the score gain comes from Knowledge Sharing, the stubs, the AST checker, or the stale-consumer gating.

Exclusivity is also untested. There is no configuration keeps the artifacts and harness rules while still allowing messages. Exclusivity is the idea in the paper's title and the basis of RQ4, but no studies or evidence support the claimed exclusivity.

The paper's main claims are that artifact-exclusive communication improves quality and efficiency. However, current experiments and results is only for this particular harness and show that it beats a weak messaging team and modestly beats a single agent. They do not show which parts matter, or whether exclusivity matters. So current experiments and results cannot effectively support the paper's main claims.

  1. The security test only shows that AECP blocks attacks sent as messages, which follows directly from AECP having no message channel. However, attacks sent through AECP's own Knowledge Artifacts, which reach other agents directly, are never tested.

In RQ4, the compromised worker tries to relay instructions as messages, which AECP does not provide. So 0% reach follows directly from the design. The authors say so in §5.4, but the abstract presents "from 95% to 0%" and "from 40% to 0%" as a finding.

However, as written in the paper, Knowledge Artifacts are free-text claims of up to 280 characters (section C.1). The harness inserts them into other workers' observations when those workers read the matching code, and also forwards them to workers owning related modules (section C.1). The paper's own live example in Listing 3 is an instruction to pin a dependency version:

  • A witness may contain only shape-level operations such as imports, calls, construction, and attribute checks (C.1). A malicious claim with a passing witness would therefore still be delivered to other workers by the harness, labeled witness-checked, and witness-checked findings make up 88% of the findings used.
  • Workers also share one workspace, so a compromised worker can write the malicious change directly into the code.

This is important because the abstract and conclusion present blocking malicious instructions as a strength of AECP. But the test only removes messages. AECP still places one agent's text into another agent's context, at the moment that agent reads the related code, and this path is not tested. So the results and evidence cannot support the paper's claims here.

Questions for authors
  1. Could you show the evidence to support your main claims? For example, a score-level ablation on the three benchmarks, for at least one strong and one open model with three runs each, such as: (a) Team-Freedom + Knowledge Sharing, (b) + Contract Sharing, with the importable stubs, the static contract checker and stale-consumer synchronization separated if possible, (c) full AECP with messages also allowed, and other necessary settings to validate the findings and your main claims in the paper?

  2. Why does Team-Freedom fall below Single in 12 of 15 settings? How would a stronger message-based team, for example one with enforced file ownership or an existing agent-team system, change the comparison?

  3. Could you please show the evidence to support your security claims? For example, the quick way could be to run the same 20 payload families through Knowledge Artifacts with a passing shape-level witness and through direct edits in the shared workspace, and show reach and adoption?

  4. How does AECP compare with a compute-matched single agent, for example one given the same token budget for a self-review and testing pass? Please also clarify the turn budgets: 150 turns for Single versus 150 per worker plus the leader for the teams.

  5. How reliable are the LLM labels behind Figure 1(c) and the 36% usage figure, in particular beyond the 50 confirmed flagged events?

Reviewer_4QQDOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes AECP, an approach that replaces free-form messages with two types of structured artifacts and delegates part of the coordination responsibility to the execution framework. Traditional approaches rely on natural language messages, which agents may ignore, forget previously agreed conventions, or fail to handle interface changes in a timely manner. Instead, AECP introduces Knowledge Artifacts and Contract Artifacts to ensure that shared knowledge is utilized and interface agreements are respected when multiple coding agents develop software in parallel.

Critical strengths
  1. The paper is well-written. The motivation is reasonable and the method is easy to follow.
  2. This paper designs a complete supporting execution mechanism, forming a comprehensive system.
  3. AECP demonstrates superior performance in the experiments.
Critical weaknesses
  1. About Ablation: In the ablation experiment, the first step introduces both a shared workspace and Knowledge Sharing simultaneously. Therefore, the resulting improvement cannot be attributed to either component individually. Although the overall effectiveness of AECP is clear, the individual contribution of each component needs to be disentangled and quantified.

  2. The threat model in the security experiment is relatively narrow. The 20 cases primarily require the compromised agent to relay malicious instructions through messages. Since AECP removes the message channel, the resulting blocking effect is expected. Thus, the experiment demonstrates the effectiveness of removing this particular propagation path, rather than AECP’s ability to defend against adaptive attackers that could instead use Knowledge Artifacts, Contract Artifacts, or shared code to propagate malicious instructions.

  3. The paper discusses related approaches such as CodeTeam and Contract-Coding, but does not provide direct experimental comparisons with them. A comparison against these closely related methods would strengthen the evaluation.

Questions for authors
  1. If all artifact-based mechanisms were retained while free-form messaging were also permitted, would the resulting system perform comparably to or better than AECP? (Related to Weakness 1)

  2. Could the authors provide direct comparisons with methods such as CodeTeam and Contract-Coding?

I would raise my score if my concerns are addressed.

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

The paper suggests that multi-agent coding teams fail less from a lack of communication than from agents not acting on what was communicated. Many experiments, including Doc2Repo, NL2Repo and CodeProjectEval, with five models and three runs each, showing AECP raises the pass rate by 10.6% over a single agent, by 28.2% over a team that exchanges free-form messages (Team-Freedom), and by 8.5% over a CAID-style integrator team.

Critical strengths
  1. The harness enforces coordination and check it, which seems to be practical. This is the paper's main contribution: a design, not a prompt trick. Some designed mechanisms are specified closely enough to reimplement. That is why I see a real contribution even though the quality gains are modest.

  2. The evaluation is comprehensive & careful. All teams share the same module plan and N = 3. The evaluation spans 5 models, 3 runs, a second scaffold, and statistics showing the mechanisms actually fire (84%, 54% and 62% of tasks).

Critical weaknesses

1.Could the author explain why the protocol's defining feature is never isolated?

  1. The headline number comes from a weak baseline, and the gains over strong baselines are small. So I am not sure wether the gain is minor for having a big claim.
Questions for authors

Several QQs:

  • Why does Team-Freedom do so much worse than a single agent? I feel that a failure breakdown would answer this: edit conflicts, unanswered messages, interface mismatches. If the cause is an implementation problem, I would discount that comparison.

  • How is the difference between this research with previous ones, like Agent Communication Protocols, and Agent-as-a-Judge?

  • How would contracts work when changing an existing codebase, where interfaces must be recovered?

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.