COOP^2: Defining, Observing, and Repairing Cooperation in LLM Multi-Agent Systems

Agents in Action

MA-Crafter

Multi-agent open-world survival with partial observability and a technology tree. Cooperative tasks are defined over resource collection and crafting, requiring multiple agents to work together.

Action Concept	Args	Effect
`noop`	steps	Do nothing for steps steps.
`move`	dir, steps	Move left/right/up/down.
`collect`	resource	Collect; all qualifying agents receive it.
`craft`	item	Craft at a tool station; requires simultaneous `craft` with a nearby quorum. Resources consumed from leader's bag; all participating agents receive the crafted item.
`sleep`	-	Recover energy.
`place`	object	Place an object in the world.
`share`	id, item, qty	Transfer resources to another agent.
`navigate`	target, id	Pathfind to target (64-step timeout).

MA-Crafter. Open-world cooperative collection and crafting with explicit participation thresholds and tool dependencies.

CUBE. Grid-world cooperative block pushing with embodied constraints from collisions and quorum-based pushing.

CUBE

Block-pushing grid world where blocks have weights that determine both their physical size and the number of agents required to push from a side simultaneously. Spatial-temporal cooperation failures emerge.

Action Concept	Args	Effect
`move`	dir, steps	Move in direction for steps steps.
`wait`	steps	Idle for steps steps (STAY).
`push`	block, steps	Push; succeeds only if a sufficient number of agents align on the same face and their combined force meets or exceeds the (possibly chained) block weight, with a free destination cell.

Overview

COOP² is an evaluation framework for studying cooperation in LLM-based multi-agent systems. It connects agents' high-level natural-language planning, communication, interruption, and replanning to the grounded actions that change task state in the environment. Cooperative tasks are represented with verifiable constraints, so the trace reveals where cooperation succeeds, where it breaks down, and why a task cannot progress.

Cognitive-Primitive Interface MAEIL Constraint-Guarded Tasks COOP²-Repair

COOP² at a glance. A cognitive-primitive interface couples symbolic agent activity with environment transitions. Cooperative constraints diagnose task progress and feed COOP²-Repair before primitive execution.

Agent trace

Records symbolic activity, committed plans, messages, interruptions, grounded actions, and task-state transitions in one aligned trace.

Cooperative tasks

Task progress is guarded by temporal, spatial or relational, participation or capability, and dependency constraints.

Targeted repair

COOP²-Repair predicts constraint failures from group plans and opens temporary repair channels for guided revisions.

Framework: Cognitive-Primitive Interface and MAEIL

To study embodied multi-agent cooperation, we need to capture three intertwined dynamics at once: how agents reason and plan individually, how they communicate and coordinate with each other, and how they jointly interact with a shared physical environment. COOP² uses the Multi-Agent Environment Interaction Loop (MAEIL) to model all three through two decoupled time scales:

Cognitive clock $\hat t$ - runs freely between environment steps. Governs reasoning ($\mathsf{R}$), interruption ($\mathsf{I}$), messaging, and plan generation. Advances as many times as needed before any primitive action is taken.

Environment clock $t$ - advances only when all agents have committed a plan and entered $\mathsf{W}$. Governs primitive execution ($\mathsf{X}$) and state transitions $s_t \to s_{t+1}$.

This decoupling lets agents think and communicate asynchronously at their own pace, while the shared environment advances at synchronized step boundaries.

Figure 2: cognitive and environment clock alignment

Cognitive and environment clocks. Plans may be generated, resumed, interrupted, or terminated while primitive execution advances only after agents commit executable plans.

Cognitive-Primitive Interface

LLMs excel at cognitive-level decisions - reasoning over goals and composing symbolic plans - but are ill-suited to specifying low-level primitive actions directly. COOP² bridges this gap with two coupled layers:

Primitive layer indexes environment steps by $t\in\mathbb{T}$ and decomposes state into active tasks, task states, and other environment variables:

$$s_t=(\mathcal{G}_t,\{x_{g,t}\}_{g\in\mathcal{G}_t},s_t^-)$$

Joint primitive actions may complete active tasks, activate new tasks, or modify existing task states.

Cognitive layer captures each agent's interaction stage and committed symbolic plan. At cognitive time $\hat t$, agent $i$ holds:

$$\hat x_{i,\hat t}=(\hat Q_{i,\hat t},\hat\pi_{i,\hat t}),\quad \hat Q_{i,\hat t}\in\{\mathsf{R},\mathsf{W},\mathsf{X},\mathsf{I}\}$$

The plan $\hat\pi_{i,\hat t}$ stores a task specification and a sequence of tool operations $\hat a_i(\theta_i)$.

The clock alignment $\kappa:\hat{\mathbb{T}}\to\mathbb{T}$ maps cognitive activity to primitive steps. For each interval $\mathcal{I}_t$, COOP² records cognitive activity $\hat X_{\mathcal{I}_t}$ and communication events $\hat M_{\mathcal{I}_t}$:

$$\hat X_{\mathcal{I}_t}=\{\hat x_{i,\tau}\}_{i\in I,\tau\in\mathcal{I}_t},\quad \hat M_{\mathcal{I}_t}=\{m_\tau\}_{\tau\in\mathcal{I}_t}$$

Each message includes a sender, recipient set, and payload, making coordination and interruption part of the trace.

Grounding $\Gamma$ bridges the two layers by unrolling tool operations into primitive actions conditioned on state and recent interaction:

$$\bigl(\{a_{i,\tau}\}_{\tau=t:t'},t'\bigr)\sim P_{\Gamma}\bigl(\cdot\mid \hat a_i(\theta_i),s_t,\hat X_{\mathcal{I}_t},\hat M_{\mathcal{I}_t}\bigr)$$

Multi-Agent Environment Interaction Loop (MAEIL)

MAEIL makes the cooperation process observable by defining explicit interaction stages that capture both agent-to-agent dynamics (reasoning, messaging, interruption) and agent-to-environment dynamics (joint execution, embodied interaction). An agent is ready when it has a committed plan and is not in active conversation with others. The environment advances only once all agents are simultaneously ready.

Step 1 - Single agent

Alternates between Reason (R) - freely reason and plan - and Execute (X) - run primitive actions.

R <-> X

Step 2 - Multi-agent, no communication

Wait (W) added - an agent enters W (ready) when it has a committed plan and is not in active conversation with others. The environment only advances once all agents are ready.

R, X -> W -> X (all ready)

Multi-agent with communication

Interrupt (I) added. Agents in R or I may send; any stage may receive:

sender: R, I --msg--> R, X, W, I :receiver

Message arrival interrupts W or X, triggering replanning before re-entering W:

W, X --msg--> I --ready--> W

Cooperation-constrained Task Design

Rather than treating cooperation as an implicit ingredient of final task success, COOP² defines cooperative tasks as state transitions guarded by verifiable cooperative constraints. For each active task $g\in\mathcal{G}_t$, the task state $x_{g,t}$, participating agents $\mathcal{I}_{g,t}$, and capability state $Z_{g,t}=\{z_{i,t}\}_{i\in\mathcal{I}_{g,t}}$ induce constraint likelihoods:

$$p^c_{g,t}=\Pr\!\left(C^c_{g,t}\mid x_{g,t},Z_{g,t}\right),\quad c\in\mathcal{C}_g=\{\Delta t,\Delta\ell,n,d\}$$

Temporal ($\Delta t$): actions must occur within the required window, often simultaneously.
Spatial or relational ($\Delta\ell$): agents must occupy the required locations or relations.
Participation or capability ($n$): enough agents with the needed capabilities must participate.
Dependency ($d$): prerequisites, tools, resources, or subtasks must be available before progress is possible.

The task-level cooperation process evolves over the active span of each task, while the episode-level trace logs how cognitive activity, messages, primitive actions, and cooperative state transitions connect:

$$\phi_{g,t}=(x_{g,t},\mathcal{I}_{g,t},Z_{g,t},\{p^c_{g,t}\}_{c\in\mathcal{C}_g}),\quad L_t=(\hat X_{\mathcal{I}_t},\hat M_{\mathcal{I}_t},a_t,\Phi_t,\Phi_{t+1})$$

Constraints are instantiated per environment as:

Constraint	MA-Crafter	CUBE
Task $g$	Collectible resource; $p(g)$ agents `collect` simultaneously within radius $d$	Side $s(g)$ of block $b(g)$; $p(g)=w_{b(g)}$ (block weight)
$C_n^i$ (participation)	$\mathrm{cap}_i(t)\succeq \mathrm{cap}(g,t)$	$\mathrm{cap}_i(t)$ (any agent)
$C_{\Delta\ell}^i$ (spatial)	$\\|x_{i,t}-y_g\\|\le d$	$\min_{y\in\mathcal{Y}_g}\\|x_{i,t}-y\\|\le 1$
$C_{\Delta t}^i$ (temporal)	$a_{i,t}=\texttt{collect}(g)$	$a_{i,t}=\texttt{push}(b(g))$

Two cooperative environment instantiations: CUBE and MA-Crafter

Environment instantiations. CUBE emphasizes spatial alignment and simultaneous pushing; MA-Crafter emphasizes capability acquisition, dependency satisfaction, and synchronized collection.

Observing the Cooperation Process

COOP² logs cooperation as a process rather than a final score. Each transition records what agents did in the cognitive layer, which messages were exchanged, which primitive actions executed, and how cooperative task states changed. This makes it possible to connect natural-language coordination to concrete task progress and constraint satisfaction.

Task progress

Score, episode length, and score per step show how much useful task progress occurs under both environment-step and wall-clock budgets.

Coordination cost

Plans per agent, messages, interruptions, and total decision time expose the overhead of reasoning, waiting, and replanning.

Constraint deficits

Spatial, temporal, and dependency deficits identify which cooperative requirements were missed during targeted task attempts.

COOP2 process traces for MA-Crafter with 3-agent teams

Process trace. Active task focus, observed constraint satisfaction, cumulative team score, and episode termination are shown across backbones and communication structures.

Stronger backbones progress better

Stronger models produce more grounded, executable plans and shift earlier from low-level resources toward tools and higher-value tasks.

More agents are not automatically better

Larger teams add capacity, but they also increase conflicts, interruptions, waiting, and decision overhead under the wall-clock budget.

Communication is not always cooperation

Centralized and Chain structures add messages and interruptions; coordination helps only when its benefits exceed synchronization cost.

Failures are constraint-specific

Dependency failures reflect planning and capability reasoning, while spatial failures remain a separate embodied coordination bottleneck.

COOP²-Repair

COOP²-Repair uses the trace before primitive execution. After agents commit plans, it groups plans by intended task, predicts whether each group can satisfy the task constraints, and opens a temporary repair channel only when failure is predicted.

Feasibility check. Group committed plans by task:

$$\mathcal{I}_{g,t}=\{i\in I:\hat\rho_{\hat\pi_{i,t}}=g\},\quad \hat\Pi_{g,t}=\{\hat\pi_{i,t}\}_{i\in\mathcal{I}_{g,t}}$$

Predict failing constraints:

$$\widehat{\mathcal{C}}^-_{g,t}=\{c\in\mathcal{C}_g:\widehat p^c_{g,t}<\tau_c\}$$

Open a repair channel for the affected group and failure reason:

$$\mathcal{R}_{g,t}=\mathcal{I}_{g,t},\quad \mathrm{ctx}_{g,t}=(g,\mathcal{I}_{g,t},\widehat{\mathcal{C}}^-_{g,t})$$

Repair trace. Gold markers indicate predicted constraint failures that trigger targeted repair rounds, shifting agents from low-level collection toward tool crafting and higher-value resources.

Communication Topologies

COOP² records interaction independently of the communication structure, allowing the same task-grounded trace to compare how different communication rules shape cooperation, overhead, and task progress. The paper compares three structures.

Individual communication structure timeline

Individual. No communication; agents plan independently without waiting or sending messages.

Centralized communication structure timeline

Centralized. A leader broadcasts to followers, waits for responses, then commits its own plan.

Chain. Agents speak in order; each later agent conditions on earlier messages before planning.

BibTeX

@article{yang2026coop2,
  title   = {COOP$^2$: Defining, Observing, and Repairing Cooperation in LLM Multi-Agent Systems},
  author  = {Yang, Hanqing and Nourzad, Narjes and Chen, Shiyu and Siew, Marie and Chen, Jingdi and Joe-Wong, Carlee},
  journal = {arXiv preprint arXiv:2603.00349},
  year    = {2026}
}

COOP2: Defining, Observing, and Repairing Cooperation in LLM Multi-Agent Systems