VI · Multi-AgentMature★★

Performative Message

also known as Speech-Act Message, KQML Performative, Typed Agent Message

Inter-agent messages are typed by communicative intent (request, inform, propose, accept, refuse, query) rather than by free-form prose, so receivers can dispatch on act type.

Context

A multi-agent system exchanges messages across agents. The default in LLM-agent deployments is free-form natural language: agent A writes a paragraph that agent B reads as a paragraph. The communicative act — is this a request? a proposal? an answer? — is implicit in the text.

Problem

Untyped messages collapse in several ways. Receivers must classify the act before dispatching, which is itself an error-prone LLM call. Audit and orchestration tools cannot tell who requested what from whom. Negotiation, query, and information-sharing protocols cannot be enforced because the protocol's state machine has no typed transitions to track. Without typing, multi-agent communication is prose all the way down and the system has no language for 'A proposed X to B, B accepted, C is querying about it'.

Forces

  • Receivers benefit from explicit act type for dispatching.
  • Protocol state machines need typed transitions to enforce contracts.
  • Free-form payloads are still needed for the act content.
  • Type vocabulary must be small and stable across agents.

Example

A negotiation protocol between two agents uses {propose, counter-propose, accept, refuse, withdraw}. Agent A sends `(propose: deliver-by Friday at $500)`. Agent B sends `(counter-propose: deliver-by Friday at $700)`. Agent A sends `(accept: $700)`. The orchestrator's audit log shows the typed exchange; no classification of free-form prose is needed.

Diagram

Solution

Therefore:

Define a small fixed set of performatives — request, inform, propose, accept, refuse, query, agree, cancel — drawn from KQML/FIPA-ACL tradition. Every inter-agent message carries an explicit performative plus the act content. Receivers dispatch on performative. Protocol state machines (negotiation, query-then-answer, contract-net) become enforceable because the transitions are typed. Free-form natural language remains the content payload; the typing is a metadata layer the LLM sees and produces.

What this pattern forbids. Inter-agent messages must not be untyped natural-language blobs; every message carries an explicit performative drawn from the fixed vocabulary.

The smaller patterns that complete this one —

  • usesContract Net Protocol★★— Classical bid-based multi-agent task allocation: a manager broadcasts a task announcement, contractors submit bids, and the manager awards the contract to the best bid.
  • usesStructured Output★★— Constrain the model's output to conform to a JSON Schema (or similar typed shape).

And the patterns that stand alongside it, or against it —

  • complementsAgent Adapter★★— An interface layer connecting an agent's tool-calling protocol to heterogeneous external tools, normalizing their schemas into one the agent expects.
  • complementsTool Use★★— Let the LLM produce typed calls against an external toolkit instead of producing free-form text the surrounding system has to parse.
  • complementsMCP Bidirectional Bridge★— Run a framework as both MCP client (consuming external MCP servers as tools) and MCP server (publishing its own agents, tools, and workflows back over MCP) so capabilities flow both directions across the protocol boundary.
  • complementsActor-Model Agents★— Implement each agent as an independent actor with its own mailbox, processing asynchronous messages one at a time and never sharing mutable state with peers.
  • alternative-toStigmergic Coordination★★— Agents coordinate indirectly by leaving and reading marks in a shared environment (files, queues, scratchpads, world model) so that one agent's trace stimulates another's next action, with no direct messaging.

Neighbourhood

Click any neighbour to follow the language. Scroll to zoom, drag to pan.

Used in recipes

Used in frameworks

References

Provenance