Gated Coordination for Efficient Multi-Agent Collaboration in Minecraft Game

1. Problem Statement

In long-horizon open-world multi-agent systems (specifically using Multimodal Large Language Models or MLLMs), existing collaboration paradigms suffer from a "communication-first" bias. Current methods typically treat any local anomaly (e.g., missing resources, path blockages) as an automatic trigger for global communication. This approach leads to three critical issues:

• Execution Interruption: Unregulated communication consumes cognitive budgets and action windows, forcing agents to suspend local plans.
• State Noise: Frequent interactions amplify global state-update noise, prematurely escalating minor local deviations into system-wide coordination events.
• False Triggers: Systems often lack cost-benefit analysis, failing to distinguish between issues that can be resolved via local self-recovery and those requiring public coordination. This results in "coordination deadlocks" and inefficient resource usage.

The core research gap is the lack of a fine-grained adjudication layer to determine when communication is truly necessary versus when an agent should handle an issue locally.

2. Methodology

The authors propose a Partitioned Information Architecture coupled with a Gated Escalation Mechanism. The system transforms communication from a default reflex into a selective, calculated decision.

A. Partitioned Information Architecture

The framework explicitly decouples the agent's state into two isolated layers to prevent context pollution:

1. Private Execution State ($m^{priv}_t$): A compact, deterministic working memory updated only via system-verified outcomes (e.g., successful item collection, block placement). It contains:
   • Inventory ($I_t$), Active Task ($T_t$), Position ($P_t$), Blockage status ($B_t$), and Verified History ($H_t$).
   • Goal: Maintain a low-noise, bounded context for local execution and self-healing.
2. Public Coordination State: A strictly protocolized channel reserved only for state-changing signals (e.g., REQUEST_MATERIAL, CANNOT_SUPPLY).
   • Goal: Eliminate conversational drift, greetings, and redundant confirmations. Communication is opened only when the gating mechanism authorizes it.

B. Gated Collaborative Escalation Policy

When a structured issue is detected (e.g., missing_material, dependency_block), the system evaluates whether to escalate to public coordination using a three-tiered decision process:

1. Heuristic Rules: Immediate handling of obvious cases (e.g., "locally recoverable immediately" or "critical path blocked").
2. Cost-Sensitive Scoring: For non-obvious cases, a score $S$ is calculated:
   $$S = w_C C + w_R R + w_I I - w_L L - w_H H$$
   • Positive Drivers: Criticality ($C$), Coordination Advantage ($R$), Downstream Impact ($I$).
   • Negative Regularizers: Local Recoverability ($L$), Coordination History Penalty ($H$).
   • Logic: High local recoverability or repeated failed requests penalize escalation.
3. Asymmetric Decision & Gray-Zone Adjudication:
   • If $S \le T_{low}$: Stay Local (Default bias to avoid unnecessary noise).
   • If $S \ge T_{high}$: Escalate (Clear need for help).
   • If $T_{low} < S < T_{high}$: Gray Zone. A bounded LLM adjudicator acts as a binary classifier to decide the path, receiving only structured JSON inputs to prevent hallucination.

C. Action Routing & Fallback

• Escalate: Opens a short-term, protocolized public window. If the request fails (e.g., CANNOT_SUPPLY), the system updates the history penalty ($H$) and triggers a Communication Cooldown, forcing the agent to fall back to local recovery or skipping the task.
• Stay Local: Routes to a deterministic local solver capable of LOCAL_RECOVER (crafting/smelting) or LOCAL_SKIP (bypassing non-critical blocks).

3. Key Contributions

1. Partitioned Information Architecture: A novel framework that separates private execution memory from public coordination states, minimizing contextual noise and hallucination risks in MLLM agents.
2. Cost-Sensitive Gating Mechanism: A hierarchical decision policy that weighs node criticality, local recovery costs, and downstream impacts to filter out unnecessary communication.
3. Event-Triggered Private Memory: A working memory updated strictly by system-verified outcomes, circumventing the risks of free-form LLM summarization.
4. Robust Fallback Systems: Mechanisms to handle coordination failures gracefully (e.g., cooldowns, local skipping) to prevent infinite deadlocks.

4. Experimental Results

The system was evaluated on MindCraft and VillagerAgent benchmarks, including custom datasets with resource constraints and dependency bottlenecks.

• Performance (Task Success Rate - TSR):
  • In custom, resource-constrained settings, the proposed method achieved 34.56% TSR (VillagerAgent + Ours) compared to the baseline's 22.04%.
  • It maintained robustness where baselines suffered severe degradation due to coordination deadlocks.
• Efficiency (Completion Steps - CS):
  • The method significantly reduced execution steps. For VillagerAgent in custom settings, steps dropped from 145 to 92.
• Coordination Quality:
  • Local Resolution Rate (LRR): Increased from ~40% (baselines) to 76.5%, proving agents successfully handle minor issues locally.
  • Unnecessary Escalation Rate (UER): Reduced drastically from ~73% to 17.4%.
  • Effective Communication Rate (ECR): Improved from ~35% to 78.2%, indicating that when communication does occur, it is highly productive.
• Ablation Studies:
  • Removing the partitioned architecture caused a surge in message count and a drop in TSR.
  • Removing the gating mechanism led to high unnecessary escalation.
  • The full model (Rules + Score + LLM Adjudicator) provided the optimal balance.

5. Significance

This paper challenges the prevailing assumption that "more communication equals better coordination" in multi-agent systems. It establishes that scalable collaborative efficiency stems not from maximizing interaction volume, but from the rigorous governance of interaction boundaries.

• Paradigm Shift: Moves from reactive, event-driven communication to proactive, cost-benefit analyzed decision-making.
• Embodied AI Insight: Demonstrates that for long-horizon tasks in open worlds, agents must prioritize local autonomy and only escalate when the marginal utility of collaboration outweighs the cost of interruption.
• Practical Application: The framework offers a blueprint for building robust, noise-resistant multi-agent systems in complex environments (like robotics or simulation) where communication bandwidth and cognitive load are limited.