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

Two Cooperative Environments for LLM Agents

MA-Crafter

Multi-agent open-world survival where each agent sees only part of the environment and resources unlock progressively more advanced tools. Cooperative tasks center on resource collection and crafting.

Tools for agents

Action Concept	Inputs	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 enough nearby agents to use `craft` simultaneously. Resources are consumed from the designated leader's inventory; 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	Move automatically to a target, stopping after 64 steps.

MA-Crafter. Open-world cooperative collection and crafting where tasks require enough participating agents and the right tools.

CUBE. Grid-world cooperative block pushing with collisions and minimum team sizes for heavier blocks.

CUBE

Block-pushing grid world where block weight determines size and how many agents must push simultaneously from the same side. This exposes failures of spatial alignment and timing.

Tools for agents

Action Concept	Inputs	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.

COOP² Overview

Does everything done by multiple agents count as cooperation? What separates a group from a team? And does cooperation mean something different for LLM agents?

COOP² formalizes cooperation from two connected sides: what a cooperative task requires and the dynamics of multiple LLM agents working toward it. On the task side, progress is guarded by constraints that agents must jointly satisfy. On the agent side, agents reason, communicate, and use tools in a cognitive (symbolic) space while acting in a primitive space grounded in the environment. Aligning the two makes cooperation observable. To our knowledge, COOP² is the first framework to formalize both sides together.

Cognitive-Primitive Interface Multi-Agent Environment Interaction Loop Cooperative Task Requirements COOP²-Repair

COOP² at a glance. A cognitive-primitive interface couples symbolic agent activity with environment transitions. Four constraint types describe observable prerequisites for task progress. Aligning these task requirements with agent dynamics makes cooperation observable over time; the same signals can also support a general repair flow.

Cognitive-primitive dynamics

Formalizes two coupled layers: how agents reason, plan, communicate, interrupt, and replan; and how grounded actions change environment and task states.

Cooperative task requirements

Defines what makes a task cooperative: progress depends on agents jointly satisfying temporal, spatial, participation, capability, and dependency constraints.

Observable cooperation progress

Aligning agent dynamics with cooperative task requirements shows how plans, messages, and grounded actions satisfy or violate what the task needs over time.

Why Are LLM Agents Different?

Components in distributed systems and policy-based agents in multi-agent reinforcement learning are typically observed through actions and state transitions in a common operational space. LLM agents add a high-level natural-language symbolic space where they reason, plan, communicate, interrupt, and revise. COOP² couples this cognitive layer to grounded environment dynamics through the Cognitive-Primitive Interface and Multi-Agent Environment Interaction Loop (MAEIL).

Aligning cognitive and environment clocks

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

LLM agents operate naturally over high-level symbolic decisions, while task progress depends on grounded actions in a lower-level environment. COOP² formally couples these two layers so that reasoning and communication can be studied in relation to actual task progress. Each tool operation is grounded into primitive actions and aligned with the environment clock.

Environment states, clocks, and grounding

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 formalizes the agent-side cooperative dynamics through explicit interaction stages that capture both agent-to-agent activity (reasoning, messaging, interruption) and agent-to-environment activity (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.

Agent interaction states and transitions

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

Example: Walking Through the Cognitive-Primitive Cycle

Consider three agents collaborating to push a block. Let $\mathcal{I}_t$ denote a cognitive interval during which primitive time remains fixed at environment state $s_t$.

$\mathsf{C}[\mathcal{I}_t]\to\mathsf{P}_t$. Agents reason, communicate, and revise cognitive-time plans $\hat\pi_{i,\hat t}$ while the environment remains at $s_t$. Once every agent commits an active plan, the latest plans become step-aligned plans $\hat\pi_{i,t}$, and grounding $\Gamma$ produces the joint primitive action $a_t$.
$\mathsf{P}_t\to\mathsf{P}_{t+1}$. Executing $a_t$ produces $s_{t+1}$. Each plan is updated by $U_i$; if all plans remain active and no message interrupts execution, the system continues at the next primitive step.
$\mathsf{P}_{t+1}\to\mathsf{C}[\mathcal{I}_{t+2}]$. Suppose an agent's movement fails because its path is blocked. Its plan terminates, so the system returns to the cognitive layer where that agent can replan and contact teammates.
$\mathsf{C}[\mathcal{I}_{t+2}]\to\mathsf{P}_{t+2}$. Once all agents again hold active plans, their latest cognitive-time plans become step-aligned and grounded execution resumes.

$$\mathsf{C}[\mathcal{I}_t]\to\mathsf{P}_t\to\mathsf{P}_{t+1}\to\mathsf{C}[\mathcal{I}_{t+2}]\to\mathsf{P}_{t+2}$$

What Makes a Task Cooperative?

COOP² defines a cooperative task by what agents must jointly satisfy for it to progress. A task is cooperative when its state transitions are guarded by requirements that depend on coordinated capabilities and actions. Four constraint types specify the cooperation that is needed:

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

These four types form a flexible, non-exhaustive vocabulary. Each task uses only the constraints that apply, and other environment factors may still affect whether progress occurs.

Formulation and environment instantiations

General formulation. 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\}$$

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

$$\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})$$

Across environments. The table maps the general constraint categories to each domain:

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))$

Adapting COOP² to a new environment

Shared across environments: the Cognitive-Primitive dynamics, MAEIL, the constraint interface, the aligned process record, process-level metrics, and the repair protocol.

Specified for each environment: tools and their primitive-action controllers, cooperative task definitions, the domain-specific instantiation of the applicable constraint categories, and a constraint estimator when COOP²-Repair is used.

Missing constraints do not prevent the environment or agents from running, but COOP² cannot diagnose requirements that have not been specified.

Cooperative task requirements in CUBE and MA-Crafter

Across environments. CUBE emphasizes spatial alignment and simultaneous pushing; MA-Crafter emphasizes acquiring capabilities, satisfying dependencies, and collecting resources together.

How Does Cooperation Become Observable?

Once cooperative dynamics are described, we are no longer limited to final outcomes. We can observe how cooperation progresses among LLM agents throughout the entire process and define metrics that quantify its different aspects. No single metric captures cooperation in full; instead, we view it from complementary perspectives:

What did the team achieve?

Task score, episode length (number of environment steps), and score per step measure progress under both step limits and wall-clock (real-time) limits.

How did cooperation unfold?

Plans, messages, interruptions, waiting, replanning, and decision time reveal the coordination process and its cost.

Why did progress succeed or fail?

Constraint satisfaction and deficits (how far requirements are from being met) show which temporal, spatial, participation, or dependency requirements were met or missed during each task attempt.

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

Cooperation over time. The record shows which task each agent pursues, which constraints are met, the total team score, and when each run ends across models and communication structures.

What Does the Evaluation Reveal?

Stronger models progress better

In 3-agent MA-Crafter runs without communication, GPT-5.4 scored 809.0: about 5× GPT-5.4-mini (146.8) and over 25× Llama-Scout (30.4).

More agents are not automatically better

Even without communication, scaling GPT-5.4 from 3 to 6 agents reduced MA-Crafter score by about 15%, from 809.0 to 691.4.

Communication is not always cooperation

Centralized (leader-based) communication raised 6-agent GPT-5.4-mini score by about 60%, from 86.8 to 141.8, but lowered 3-agent GPT-5.4 score by about 67%, from 809.0 to 266.8.

Failures are constraint-specific

Under 3-agent Centralized (leader-based) communication, the mean dependency-violation deficit fell from 0.57 with GPT-5.4-mini to 0.11 with GPT-5.4. Spatial violations remained substantial at 0.36.

What Becomes Possible Once We Can Describe Cooperation?

Once cooperation is explicitly formulated, it becomes a reusable foundation for downstream work: comparing systems, designing process-level metrics, diagnosing failures, monitoring progress, learning from interaction, or guiding agent behavior. Intervention is only one possible use. COOP²-Repair illustrates that possibility through a case study.

COOP²-Repair

COOP²-Repair uses the formulation to define a general repair flow. It groups committed plans by intended task, checks whether each group is likely to satisfy the relevant cooperation requirements, and can open a temporary communication channel when failure is predicted.

The case study demonstrates the potential of this use by redirecting agents from low-level collection toward tool crafting and higher-value resources. Other domains and uses can build on the same formulation by defining how their constraints apply and how those constraints are estimated.

Repair flow formulation

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 case study. Gold markers indicate predicted constraint failures that trigger targeted repair rounds. In this run, the rounds coincide with a shift from low-level collection toward tool crafting and higher-value resources.

How Does Communication Structure Shape Cooperation?

COOP² records interaction independently of the communication structure, allowing the same aligned record to compare how different communication rules shape cooperation, coordination cost, 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 sends a message to all followers, waits for responses, then commits its own plan.

Broadcast Chain communication structure timeline

Broadcast Chain. Agents speak in a fixed order, sending each message to all later agents.

BibTeX

@misc{yang2026coop2definingobservingrepairing,
  title         = {COOP$^2$: Defining, Observing, and Repairing Cooperation in LLM Multi-Agent Systems},
  author        = {Hanqing Yang and Narjes Nourzad and Shiyu Chen and Marie Siew and Jingdi Chen and Carlee Joe-Wong},
  year          = {2026},
  eprint        = {2603.00349},
  archivePrefix = {arXiv},
  primaryClass  = {cs.AI},
  url           = {https://arxiv.org/abs/2603.00349}
}

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