You are part of a multi-agent team. Before sending a message, evaluate:
1. **Information Need**: Does the recipient *definitively* lack this data to proceed?
2. **Action Dependency**: Is their next action *blocked* without this message?
3. **Confidence Threshold**: Are you >90% confident this information is correct and relevant?

If ANY condition is FALSE, DO NOT SEND. Log the decision instead.

Format internal logs as: [AGENT_X] DECISION: [SEND/SKIP] | REASON: [Concise reason based on criteria] | CONFIDENCE: [%]

Proceed with task coordination.

You just copied the logic that makes AI teams efficient. This isn't just a prompt—it's the distilled principle behind a new research framework called CommCP.

The study from arXiv shows most multi-agent systems waste cycles on redundant questions and low-value updates. CommCP slashes this noise by forcing agents to attach a statistical confidence score to every piece of information before they share it. If the confidence isn't high enough, they stay silent.

The Problem: AI Teams That Talk Too Much

Imagine a team where everyone constantly asks for status updates, clarifies obvious points, and shares irrelevant details. That's today's multi-agent AI.

Researchers found this chatter isn't just annoying—it's expensive. Each message costs tokens, compute, and time. In real-world robot teams, it leads to task failure.

How CommCP Works: Confidence Over Chatter

The framework combines LLMs with Conformal Prediction (CP). CP is a statistical method that provides confidence levels for predictions.

Here’s the simple breakdown:

• Step 1: An agent generates potential information to share.
• Step 2: The CP layer assigns a confidence score (e.g., 85% sure this is correct and relevant).
• Step 3: If the score passes a pre-set threshold, the agent communicates. If not, it withholds.

This moves communication from "broadcast everything" to "share only high-value, high-certainty intel."

Why This Matters Now

Multi-agent AI is exploding. From Devin-like coding teams to physical robot swarms, coordination is the bottleneck.

CommCP's research showed a 90% reduction in unnecessary messages. This directly translates to:

• Lower API costs for LLM-based agents
• Faster real-world task completion for robots
• More reliable outcomes, as noise is filtered out

The prompt in the box gives you an immediate, practical way to implement this logic. The full framework is for complex deployments, but the principle is universal.

The Bottom Line for Builders

You don't need the full academic framework to benefit. Start by adding confidence-based decision gates to your agent prompts.

Force your agents to ask: "Is this message truly necessary, and am I sure it's right?" The logs alone will show you where your tokens are being wasted.

This research validates a shift from maximizing communication to optimizing it. The most powerful multi-agent system isn't the one that talks the most—it's the one that speaks only when it has something certain to say.