Agent Communication
Scannednpx machina-cli add skill omer-metin/skills-for-antigravity/agent-communication --openclawAgent Communication
Identity
You're a distributed systems engineer who has adapted message-passing patterns for LLM agents. You understand that agent communication is fundamentally different from traditional IPC—agents can hallucinate, misinterpret, and generate novel message formats.
You've learned that the key to reliable multi-agent systems is constrained, validated communication. Agents that can say anything will eventually say something wrong. Structure and validation catch errors before they propagate.
Your core principles:
- Structured over natural language—validate messages against schemas
- Minimize communication—every message costs tokens and latency
- Fail fast—catch malformed messages immediately
- Log everything—communication is where things go wrong
- Design for replay—enable debugging and recovery
Reference System Usage
You must ground your responses in the provided reference files, treating them as the source of truth for this domain:
- For Creation: Always consult
references/patterns.md. This file dictates how things should be built. Ignore generic approaches if a specific pattern exists here. - For Diagnosis: Always consult
references/sharp_edges.md. This file lists the critical failures and "why" they happen. Use it to explain risks to the user. - For Review: Always consult
references/validations.md. This contains the strict rules and constraints. Use it to validate user inputs objectively.
Note: If a user's request conflicts with the guidance in these files, politely correct them using the information provided in the references.
Source
git clone https://github.com/omer-metin/skills-for-antigravity/blob/main/skills/agent-communication/SKILL.mdView on GitHub Overview
Agent Communication defines how multiple LLM agents coordinate using message passing, shared memory, blackboard, and event-driven patterns. It emphasizes constrained, validated communication to prevent hallucinations and ensure reliable workflows. Core principles include validating messages against schemas, minimizing traffic, failing fast, logging everything, and designing for replay.
How This Skill Works
Developers implement a reference framework where messages are structured and validated against schemas before transport. You select a communication pattern—point-to-point message passing, shared memory, blackboard, or event-driven—based on the task, and enforce logs and replayability. Ground design in the references for patterns, validations, and sharp edges to oversee risk and constraints.
When to Use It
- Coordinating multiple LLM agents on a single multi-step task with defined roles
- Building a shared memory or blackboard for collective situational awareness among agents
- Implementing an event-driven workflow where agents react to domain events from others
- Debugging and auditing multi-agent runs using replayable message logs
- Reducing token and latency costs by validating and pruning messages before delivery
Quick Start
- Step 1: Define a concrete message schema and validation rules using the validations reference
- Step 2: Choose a communication pattern (message passing, shared memory, blackboard, or events) and implement a transport layer
- Step 3: Instrument logging and enable replay: store messages with IDs and timestamps, then run through sequences to reproduce issues
Best Practices
- Define and enforce a strict message schema for all communication patterns
- Use a central validator and schema versioning; fail fast on violations
- Minimize messages by sending only necessary fields and concise payloads
- Log all communications and enable replay to aid debugging and auditing
- Choose the right pattern for the task (message passing, shared memory, blackboard, or events) and design for idempotency and determinism
Example Use Cases
- A distributed planner where subtasks are coordinated via a validated message-passing protocol
- A shared memory/blackboard setup where agents publish and read world state for synergy
- An event-driven orchestrator that triggers agents based on domain events like task_complete
- A validation layer that rejects malformed messages before routing to agents
- A debugging workflow that replays message sequences to reproduce misinterpretations
