Principles for Multi-Agent Communication in Semantic Systems

Author: Scott Senkeresty
Date: 2025-12-03
Status: Canonical
Related Projects: agent-ether, Scout, Groqqy, Semantic OS Layer 3

Abstract

This document establishes foundational principles for multi-agent system coordination. When autonomous reasoning processes (LLM-based agents) communicate, they require structured protocols—not implicit "vibes." Drawing from Unix philosophy, organizational theory, military command doctrine, and distributed systems, we define seven core principles and a minimal six-phase protocol for safe, transparent multi-agent communication.

Core Thesis: Intelligence scales with coordination, not opacity. Multi-agent systems need protocols, not vibes.

Scope Note: This document addresses horizontal coordination (how agents at the same level communicate). For vertical structure (how agents at different hierarchical levels interact with different amounts of agency and context), see the companion document HIERARCHICAL_AGENCY_FRAMEWORK.md. Together, these two frameworks provide a complete multi-agent architecture.

The Problem: Vibe Coding

When engineers attempt their first multi-agent system, the workflow usually looks like this:

  1. Write a prompt for Agent A
  2. Have Agent A call Agent B
  3. Hope the context passes through correctly
  4. Pray both produce something coherent

This approach has a name: vibe coding. Two agents gesture vaguely at each other through natural language, exchanging meaning by implication, hoping intention survives the journey.

It works—until it doesn't.

Failure Modes

The collapse is predictable:

After enough of this, a simple truth emerges:

You cannot build a multi-agent system with vibes. You need a protocol.

Why Vibes Fail

Modern LLM-based agents operate like probabilistic reasoning processes. They are powerful, adaptive, and generative—but they are not deterministic state machines.

When one agent relies on another agent's output without structure, the system inherits the worst properties of both:

If two agents communicate only through freeform prompting, meaning becomes implicit and unstable. Nothing ensures:

This is not coordination. It is improvisation.

Every other field that has faced similar challenges—concurrency, distributed systems, organizational design, military command—developed protocols, not vibes.

Multi-agent systems now need the same.

The Seven Principles

1. Agents Communicate Intent, Not Instructions

In human organizations, instructions are brittle. Intent is stable.

Intent survives uncertainty. Instructions do not.

Protocol Rule:

An agent should receive the purpose of a task, the constraints, and the definition of success—not a chain of fragile steps.

This allows sub-agents to adapt within boundaries while maintaining semantic correctness.

Without intent, every delegation collapses into a telephone game.

2. All Agent Communication Must Be Typed

Unix pipelines succeeded because programs communicated using typed streams: bytes with agreed-upon structure.

Distributed systems succeed because services communicate using formal API contracts.

Multi-agent systems require the same:

Protocol Rule:

Natural language alone is not a contract. It is a medium. A protocol requires structure.

3. Roles Must Be Explicit

When agents have unclear roles, two failures occur:

  1. Hallucinated authority: an agent improvises decisions it should not make.
  2. Responsibility diffusion: all agents assume others are checking the work.

Human organizations solved this long ago through structures like RACI:

Protocol Rule:

Agents need the same. Without explicit roles, delegation becomes unstable.

4. Autonomy Must Be Bounded

Unbounded autonomy creates:

Every agent must have:

This mirrors Rules of Engagement in mission command doctrine.

Protocol Rule:

Autonomy is granted, not assumed.

5. Uncertainty Does Not Permit Creativity

In deterministic software, uncertainty is a state.

In LLMs, uncertainty becomes improvisation.

This is dangerous.

Protocol Rule:

When uncertain, an agent must: Stop → Escalate → Ask.

It may not "be creative" or invent missing context.

This isn't an artistic system. It's an architecture.

6. Provenance Is the Substrate of Trust

In distributed systems, logs and traces provide:

Agents need the same, but with semantic provenance:

Protocol Rule:

Without provenance, multi-agent systems become opaque and untrustworthy.

This is how "black-box AGI" emerges—not from a model's intelligence, but from a system's lack of structure.

7. Parallelism Requires Synthesis

When many agents act in parallel, someone must integrate their outputs.

Human organizations learned this:

Agents need the same:

Protocol Rule:

Otherwise, redundant or conflicting outputs accumulate, and the system diverges.

The Minimal Protocol

A robust multi-agent communication protocol reduces to six phases:

1. Intent

The purpose, constraints, and success criteria.

2. Contract

Schemas for input, output, and error.

3. Context

Typed semantic state:

4. Execution

Bounded autonomy within constraints.

5. Verification

Check correctness against schema and intent.

6. Synthesis

Integrate results, resolve conflicts, propagate upward.

This is the cognitive equivalent of:

It is the opposite of vibe coding.

A Minimal Example

Below is an intentionally small, K&R-style demonstration:

Supervisor Agent

Intent: "Summarize the latest research on semantic memory systems. Identify three open problems. Ensure correctness."

Contract:
- Input: search results
- Output: structured object {summary, open_problems[]}
- Errors: ambiguity, insufficient data

Execution:
- Delegates search to ResearchAgent
- Delegates synthesis to AnalystAgent

ResearchAgent

AnalystAgent

Supervisor then verifies and synthesizes.

Small. Stable. Deterministic. Not vibes.

The Glass-Box Future

The AI industry is accelerating toward centralized, monolithic systems that appear intelligent but lack transparency.

These systems are powerful, but opaque—black boxes that absorb intent and return conclusions with little insight into the reasoning that produced them.

The Alternative

The alternative is not smaller models. It is structured coordination.

Multi-agent systems become safe and reliable only when:

A system built on these principles is not a black box. It is a glass box:

And once you see the difference, the future becomes clear:

Intelligence scales with coordination, not opacity.

Multi-agent systems need protocols, not vibes.

And the foundation of transparent AI is semantic communication.

Connection to SIL Projects

This protocol foundation directly informs:

agent-ether (Layer 3: Orchestration)

Multi-agent orchestration protocols for Semantic OS. This document provides the theoretical foundation for agent-ether's communication primitives.

Scout + Groqqy

Scout's multi-phase research orchestrator (developed Dec 2025) demonstrates these principles:

Key Insight: Breaking deep research into focused phases (5-10 iterations each) prevents LLM early-stopping and achieves 100% reliability for Phases 1-3.

Reference: TIA session documentation (Multi-phase orchestrator)

Semantic OS Architecture

Layer 3 (Orchestration) requires these protocol primitives as first-class citizens:

Academic Foundations

SIL Canonical Docs

Future Work

Implementation Priorities

  1. agent-ether protocol specification - Formalize the 6-phase protocol
  2. Typed message schemas - Define standard envelopes for inter-agent communication
  3. Provenance primitives - Build semantic trace infrastructure
  4. Escalation patterns - Define when/how agents ask for help
  5. Synthesis algorithms - Deterministic multi-agent output integration

Research Questions

  1. How do we type "meaning" in agent communication?
  2. What is the minimal schema for semantic provenance?
  3. Can we prove correctness bounds for bounded-autonomy agents?
  4. How does this protocol compose with human-in-the-loop?
  5. What are the performance characteristics of glass-box vs black-box agents?

Conclusion

Multi-agent systems are not a future problem. They are a present need.

Every AI system that delegates, coordinates, or synthesizes across multiple reasoning processes faces the same challenge:

Will it communicate through vibes, or through protocols?

Vibes scale to demos. Protocols scale to production.

This document provides the foundation for the latter.

The rest is engineering.

Appendix: Key Quotes

"You cannot build a multi-agent system with vibes. You need a protocol."

"Intent survives uncertainty. Instructions do not."

"When uncertain, an agent must: Stop → Escalate → Ask."

"Intelligence scales with coordination, not opacity."

"This isn't an artistic system. It's an architecture."

Changelog