Principles for Multi-Agent Communication in Semantic Systems
Author: Scott Senecal
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:
- Write a prompt for Agent A
- Have Agent A call Agent B
- Hope the context passes through correctly
- 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:
- Agents hallucinate authority they don't have
- Context fragments across steps
- Roles blur and intermingle
- Delegation loops become infinite
- Output formats drift
- Downstream agents reinterpret upstream intent
- Systems collapse under ambiguity alone
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:
- Ambiguity drift
- Implicit assumptions
- Context loss
- Unbounded creativity
If two agents communicate only through freeform prompting, meaning becomes implicit and unstable. Nothing ensures:
- The intent is preserved
- The task is correctly interpreted
- The output matches expectations
- The receiving agent understands the schema
- Failures are detected
- Ambiguity is escalated
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.
- "Take Hill 402" is an instruction.
- "Prevent enemy artillery from targeting the village" is intent.
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:
- Input schemas
- Output schemas
- Error schemas
- Context envelopes
- Provenance metadata
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:
- Hallucinated authority: an agent improvises decisions it should not make.
- Responsibility diffusion: all agents assume others are checking the work.
Human organizations solved this long ago through structures like RACI:
- Responsible: who produces the output
- Accountable: who verifies correctness
- Consulted: who provides context
- Informed: who receives results
Protocol Rule:
Agents need the same. Without explicit roles, delegation becomes unstable.
4. Autonomy Must Be Bounded
Unbounded autonomy creates:
- Unbounded creativity
- Unbounded error
- Unbounded risk
Every agent must have:
- Limits on what it can decide
- Conditions under which it must escalate
- Types of tasks it is allowed to perform
- Depth of delegation permitted
- Resource budgets (tokens, time, recursion)
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:
- Debugging
- Auditing
- Reproducibility
- Observability
Agents need the same, but with semantic provenance:
- What the agent saw
- What it believed
- What constraints applied
- What context it relied on
- What outputs it generated
- What its reasoning chain was
- How it justified decisions
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:
- Teams gather data
- Managers synthesize it
- Leaders make decisions
Agents need the same:
- Parallel work is fine
- But synthesis must be centralized and deterministic
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:
- Memory
- Assumptions
- Environment
- Provenance
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:
- API definition
- Function invocation
- Error handling
- Typed pipelines
- Concurrency control
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
- Retrieves sources
- Returns typed list of documents
- Escalates if relevance < threshold
AnalystAgent
- Produces structured output
- Flags uncertainty explicitly
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:
- Messages are typed
- Roles are explicit
- Intent is clear
- Autonomy is bounded
- Uncertainty triggers escalation
- Provenance is preserved
- Synthesis is centralized
A system built on these principles is not a black box. It is a glass box:
- Layered
- Observable
- Interpretable
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:
- Intent: Research Gems Discovery methodology
- Contract: Typed phase outputs (structure, implementation, tests, innovations)
- Context: Memory persistence across phases
- Execution: Bounded iteration limits per phase
- Verification: Output validation between phases
- Synthesis: Multi-phase aggregation into final report
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: /home/scottsen/src/tia/sessions/noble-warrior-1203/ (Multi-phase orchestrator)
Semantic OS Architecture
Layer 3 (Orchestration) requires these protocol primitives as first-class citizens:
- Intent propagation through semantic IR (Layer 1: USIR/Pantheon)
- Typed message passing (Layer 2: Domain bridges)
- Provenance tracking (Layer 0: Semantic memory)
- Agent coordination patterns (Layer 3: agent-ether)
Related Work
Academic Foundations
- Mission Command Doctrine: Intent-based delegation under uncertainty
- Unix Philosophy: "Do one thing well" + composable pipelines
- Organizational Theory: RACI matrices, Conway's Law
- Distributed Systems: Typed contracts, observability, consensus
SIL Canonical Docs
SIL_MANIFESTO.md- The why (systems should be semantic)SIL_PRINCIPLES.md- The how (progressive disclosure, verification)SIL_SEMANTIC_OS_ARCHITECTURE.md- The what (Layer 3 orchestration)- This document - The protocol (how agents coordinate safely — horizontal axis)
HIERARCHICAL_AGENCY_FRAMEWORK.md- The structure (how agents are organized — vertical axis)
Future Work
Implementation Priorities
- agent-ether protocol specification - Formalize the 6-phase protocol
- Typed message schemas - Define standard envelopes for inter-agent communication
- Provenance primitives - Build semantic trace infrastructure
- Escalation patterns - Define when/how agents ask for help
- Synthesis algorithms - Deterministic multi-agent output integration
Research Questions
- How do we type "meaning" in agent communication?
- What is the minimal schema for semantic provenance?
- Can we prove correctness bounds for bounded-autonomy agents?
- How does this protocol compose with human-in-the-loop?
- 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
- 2025-12-04: Added cross-reference to companion document HIERARCHICAL_AGENCY_FRAMEWORK.md (vertical structure)
- 2025-12-03: Initial canonical document created
- Captured from turbulent-current-1203 session analysis
- Grounded in Scout/Groqqy multi-phase orchestrator experience
- Connected to agent-ether, Semantic OS Layer 3, and SIL research agenda