LearnPython

Heritage of FIPA-ACL and Speech Acts

Before MCP and A2A there was FIPA-ACL. In 2000 the IEEE Foundation for Intelligent Physical Agents ratified an agent communication language with twenty performatives, two content languages, and a set of interaction protocols: contract net, subscribe/notify, request-when. It faded from industry because the ontology overhead was too heavy for the web. The LLM revival of multi-agent systems is reimplementing the same ideas without the formal semantics, with JSON contracts standing in for performatives and natural language standing in for ontologies. Reading FIPA-ACL seriously shows you which 2026 protocol decisions are reinvention, which are novelty, and where the current wave is going to rediscover problems the 2000s already solved.

TIME: ~60 minutesPREREQUISITES: Phase 16 · 01 (Why Multi-Agent)

Learning Objectives

Explain how speech-act theory, KQML, and FIPA-ACL connect, and what a performative is.
Map MCP, A2A, and CA-MCP message shapes onto FIPA performatives and interaction protocols.
Name why FIPA-ACL faded and which of its costs (ontology, formal semantics, tooling) modern specs dropped.
Pick the interaction protocol (contract-net, subscribe/notify, request-when) that fits a given coordination problem.
Diagnose semantic drift and choose a mitigation that stops short of a full ontology.

Problem

The 2026 agent-protocol landscape is crowded: MCP for tools, A2A for agents, ACP for enterprise audit, ANP for decentralized trust, NLIP for natural-language content, plus CA-MCP and two dozen research proposals. Each spec announces itself as foundational.

Most of them are rediscovering a twenty-year-old decision tree. Austin (1962) and Searle (1969) gave us speech-act theory, the idea that utterances are actions. KQML (1993) turned that into a wire protocol. FIPA-ACL (ratified 2000) was the reference standardization: twenty performatives, content languages SL0/SL1, and interaction protocols for contract-net and subscribe-notify. JADE and JACK were the Java reference platforms. The effort faded around 2010 because the ontology overhead was too heavy and the web was winning.

Look at MCP's tools/call, A2A's task lifecycle, or CA-MCP's shared context store and you are looking at a softer, JSON-native rehash of FIPA decisions. That tells you which new "innovations" are reinventions, and which old failure modes the new specs will hit again.

Warm-up0/3

1. A single agent keeps dropping details it read early in a long task, and its context window is nearly full. Which reason for going multi-agent does this describe?Warm-up

A single assistant box above a row of five numbered notes, the earliest two faded, over a nearly full reading-list bar, with a dashed box asking what happens to the early notes.

2. Two agents have to cooperate on one task. Why does the system need an explicit communication contract between them?Warm-up

3. A client has several requests in flight to one server over a single connection. What lets it match each reply to the right request?Warm-up

A client box sending three labelled requests down to a server box, with a dashed note that the replies come back in a different order and a question about how to match each reply to its request.

Check: Problem0/1

1. What is FIPA, and in which year did it standardize the agent communication language?Define

A lineage chain from speech-act theory through KQML to FIPA-ACL to its fading around 2010, with a dashed box over FIPA-ACL asking who ratified it and when.

Concept

Speech acts, in one paragraph

Austin noticed that some sentences do not describe the world. They change it: "I promise." "I request." "I declare." He called these performative utterances. Searle formalized five categories: assertive, directive, commissive, expressive, declarative. KQML (Finin et al., 1993) made this operational for software agents. A message is a performative (the action) plus content (what the action is about). FIPA-ACL cleaned up KQML's gaps and standardized around twenty performatives.

The twenty FIPA performatives (partial list)

Performative	Intent
`inform`	"I tell you P is true"
`request`	"I ask you to do X"
`query-if`	"Is P true?"
`query-ref`	"What is the value of X?"
`propose`	"I propose we do X"
`accept-proposal`	"I accept the proposal"
`reject-proposal`	"I reject the proposal"
`agree`	"I agree to do X"
`refuse`	"I refuse to do X"
`confirm`	"I confirm P is true"
`disconfirm`	"I deny P"
`not-understood`	"Your message did not parse"
`cfp`	"Call for proposals on X"
`subscribe`	"Notify me when X changes"
`cancel`	"Cancel the ongoing X"
`failure`	"I tried X and failed"

The full list is in fipa00037.pdf (FIPA ACL Message Structure). Don't memorize it. What matters is that each of these maps to a primitive an LLM protocol ends up re-adding.

Canonical FIPA-ACL message

(inform
  :sender       agent1@platform
  :receiver     agent2@platform
  :content      "((price IBM 83))"
  :language     SL0
  :ontology     finance
  :protocol     fipa-request
  :conversation-id   conv-42
  :reply-with   msg-17
)

Seven fields carry the protocol envelope and one field (content) carries the payload. Those seven are what you end up reinventing when you bolt retries, threading, and ontology onto a JSON protocol.

The two legacy platforms

JADE (Java Agent DEvelopment framework, 1999–2020s) was the most-used FIPA-compliant runtime. Agents extended a base class, exchanged ACL messages, ran inside containers, and coordinated through "behaviors." Its interaction-protocol library shipped with contract-net, subscribe-notify, request-when, and propose-accept.

JACK (Agent Oriented Software, commercial) emphasized BDI (Belief-Desire-Intention) reasoning on top of FIPA messages. More formal, less adopted.

Both declined once the web stack took over multi-agent use cases. MCP and A2A play the role of the runtime "containers" in 2026.

Why FIPA faded

Ontology overhead. FIPA required a shared ontology to parse content, and agreeing on an ontology is a years-long standards process. The web just used HTTP + JSON.
Formal semantics few people used. SL (Semantic Language) gave rigorous truth conditions, but most production systems used free-form content and ignored the formalism.
Tooling lock-in. JADE was Java-only and JACK was commercial. Polyglot teams routed around both.
The internet won the stack. REST, then JSON-RPC, then gRPC replaced ACL's transport.

The LLM revival is FIPA-lite

Compare a FIPA request to an MCP tools/call:

(request                                {
  :sender  agent1                         "jsonrpc": "2.0",
  :receiver tool-server                   "method":  "tools/call",
  :content "(lookup stock IBM)"           "params":  {"name":"lookup_stock",
  :ontology finance                                   "arguments":{"symbol":"IBM"}},
  :conversation-id c42                    "id": 42
)                                        }

Same envelope, different syntax. Both carry who, whom, intent, payload, and a correlation id. Neither is a revolution over the other. They are different trade-offs on the same design.

The 2025 survey by Liu et al. ("A Survey of Agent Interoperability Protocols: MCP, ACP, A2A, ANP", arXiv:2505.02279) makes the lineage explicit. MCP corresponds to tool-use speech acts, A2A to agent-peer speech acts, ACP to audit-trail speech acts, and ANP to decentralized-identity extensions. The new specs are ACL descendants with JSON syntax and looser semantics.

The trade-off, stated plainly

What FIPA gave you and modern specs drop:

Formal semantics, so you can prove inform implies the sender believes the content.
A canonical catalog of performatives, so you do not have to re-argue "should we have a cancel?".
Decades of interaction-protocol patterns (contract-net, subscribe-notify, propose-accept) with known correctness properties.

What modern specs give you and FIPA did not:

JSON-native payloads compatible with every modern tool.
Natural-language content that LLMs can interpret without a hand-coded ontology.
Web-stack transport (HTTP, SSE, WebSocket).
Capability discovery via self-describing documents (MCP listTools, A2A Agent Card).

The price is looser intent semantics. That is the trade, and it buys you easier implementation.

Interaction protocols worth porting

FIPA shipped ~15 interaction protocols. Three are worth carrying forward into LLM multi-agent systems:

Contract Net Protocol (CNP). Manager issues cfp (call for proposals); bidders respond with propose; manager accepts/rejects. This is the canonical task-market pattern (Phase 16 · 16 Negotiation).
Subscribe/Notify. Subscriber sends subscribe; publisher sends inform whenever the topic changes. Most event buses in 2026 are this pattern.
Request-When. "Do X when condition Y holds." Delayed-action with pre-conditions. The 2026 analog is deferred tasks in durable workflow engines (Phase 16 · 22 Production Scaling).

Each maps onto modern message queues, HTTP + polling, or SSE streaming without much strain.

What breaks when you drop the ontology

Without a shared ontology, agents infer meaning from natural-language content. The documented 2026 failure mode is semantic drift. Two agents use the same word ("customer") for subtly different concepts, the receiving agent acts on the wrong interpretation, and no schema validator catches it. FIPA's ontology requirement would have rejected the message at parse time.

Mitigations without going full ontology:

JSON Schema on content rejects structural errors at the wire.
Typed artifacts (A2A) reject the wrong modality.
An explicit performative in the envelope makes intent unambiguous even when content is natural language.

The 2026 specs, mapped to speech-act heritage

Modern spec	FIPA analog	What it keeps	What it drops
MCP `tools/call`	`request`	explicit intent, correlation id	formal semantics, ontology
MCP `resources/read`	`query-ref`	explicit intent, correlation id	formal semantics
A2A Task lifecycle	contract-net + request-when	async lifecycle, state transitions	formal completeness guarantees
A2A streaming events	subscribe/notify	async push	typed-predicate subscription
CA-MCP shared context	blackboard (Hayes-Roth 1985)	multi-writer shared memory	logical consistency model
NLIP	natural-language content	LLM-native	schema

Read the table top to bottom and the pattern is clear: keep the structural primitive, drop the formalism, and let the LLM paper over the ambiguity.

Check: Concept0/24

1. What is the central idea of speech-act theory, the theoretical parent of ACL?Define

2. How does an ACL message divide its fields, as in the canonical FIPA-ACL example?Define

The canonical FIPA-ACL message from the Concept section, all nine lines shown together ungrouped, with a dashed box asking how many fields count as envelope and how many as payload. — The example is copied verbatim from the lesson's Concept section.

3. What is a performative in an ACL message?Define

An abridged version of the canonical message with only the word inform and a dashed box asking its role, the other lines present but not singled out. — Abridged from the lesson's Concept section.

4. What was KQML, and how does it relate to FIPA-ACL?Define

5. What is an ontology in FIPA's design?Define

An abridged canonical message with the ontology field highlighted and a dashed box asking what it is for, next to a note that content names price, IBM and 83 with no definitions attached. — Abridged from the lesson's Concept section.

6. What are SL0 and SL1 in FIPA?Define

An abridged canonical message with the language field set to SL0 and a dashed box asking what SL0 is, with a note that SL1 is the table's other level and not shown. — Abridged from the lesson's Concept section.

7. Which description of the two legacy platforms, JADE and JACK, is correct?Define

8. What is the Contract Net protocol?Define

One manager box above three bidder boxes with arrows down to each, and a dashed box asking what the pattern of messages here is called. — Typed schematic, not captured output.

9. What is a FIPA interaction protocol?Define

Three generic boxes labelled performative 1, 2 and 3 joined by arrows in a fixed order, with a note that a random swap is not guaranteed to work and a dashed box asking what this fixed order is called. — Typed schematic, not captured output.

10. The subscribe/notify pattern has no `notify` performative in the table. How does the publisher tell the subscriber about a change?Explain

11. In a KQML message, why is the performative kept separate from the content?Explain

One message box split into two unlabelled parts, part 1 and part 2, with a note that the same example content could be told, asked about or proposed. — Typed schematic, not captured output.

12. In the mapping table of 2026 specs, which FIPA interaction protocol do A2A streaming events correspond to?Explain

A server and a client joined by one open HTTP response carrying three small event chips, with a dashed box asking which FIPA interaction protocol this matches. — Typed schematic, not captured output.

13. The Liu et al. survey ties modern protocols to speech-act families. Which family does it assign to A2A?Explain

14. What does CA-MCP's shared context map to in the mapping table, and what does it drop?Explain

A CA-MCP shared context box above a dashed box asking for its FIPA analog and a dashed box asking what it drops, with a note that the lesson's table pairs five other specs this way too.

15. MCP `tools/call` maps to a FIPA `request`. What does that mapping keep and drop?Explain

An MCP tools/call to request box above a dashed box asking what it keeps and a dashed box asking what it drops, with a note naming request as the FIPA performative it maps to.

16. Which set of reasons explains why FIPA faded?Explain

A why FIPA faded heading above four dashed boxes, each asking for one reason.

17. What do modern specs such as MCP and A2A gain by dropping FIPA's ontology requirement, and what does it cost?Explain

18. How does Request-When differ from Subscribe/Notify?Explain

Two unnamed lanes, one that acts once a condition becomes true and one that keeps sending whenever a topic changes, with a dashed box asking which name goes with which. — Typed schematic, not captured output.

19. Two agents exchange JSON where `customer` means a billing account to one and an end user to the other. The message validates and the wrong record gets updated. What failure is this?Analyze

Agent 1 using customer to mean a billing account and agent 2 using it to mean an end user, with a message carrying that word between them, a note that the wrong record gets updated, and a dashed box asking what failure this is.

20. A team adds JSON Schema to the `content` field, yet an agent still acts on the wrong `customer`. What best explains it?Analyze

21. A vendor calls its protocol a breakthrough. Every message has an intent field, a correlation id, a payload, and sender and receiver. What does the lesson's view suggest?Analyze

A claimed new protocol's message fields next to a dashed box asking if it is genuinely new, with a note that every message has an intent, a correlation id, a payload and sender and receiver.

22. An inventory dashboard agent must be told whenever a stock count changes, without polling. Which interaction protocol from the Interaction protocols worth porting section fits?Design

An inventory dashboard that must be told whenever a stock count changes without polling, with a dashed box asking which interaction protocol fits.

23. A workflow needs a cleanup task requested once, to run only after all upstream jobs have finished. Which interaction protocol fits?Design

A cleanup task that runs once, only after all upstream jobs finish, with a dashed box asking which interaction protocol fits.

24. You cannot adopt a full ontology but want to cut semantic drift. Which set of mitigations does the Concept section recommend?Design

A heading reading can't adopt a full ontology above three dashed boxes, each asking for one mitigation.

Build It

code/main.py is a pure-stdlib FIPA-ACL translator. It renders the canonical ACL envelope and shows how MCP and A2A message shapes reduce to the same seven envelope fields. The demo:

Translates four MCP-style and A2A-style messages (tools/call, resources/read, task creation, and an SSE subscription) into FIPA-ACL.
Runs a toy Contract Net negotiation between one manager and three bidders using cfp, propose, accept-proposal, reject-proposal.

Run:

python3 code/main.py

The output prints each modern message in its 2026 JSON form followed by its FIPA-ACL form, then the full contract-net message log. The structural primitives carry over unchanged; only the syntax differs.

Check: Build It0/9

1. What does `code/main.py` do, per the Build It section and the Author's Note?Explain

A main.py box labelled translators plus a negotiation demo, with a dashed box asking exactly what it does.

2. `mcp_tools_call_to_acl` receives a request whose JSON-RPC id is 42. What conversation id and reply-with does the resulting ACLMessage carry?Apply

An MCP tools/call request with id 42, and a dashed box asking for the resulting ACL message's conversation id and reply-with, with a note about the canonical example's own values.

3. The translator receives `{"method": "resources/read", "params": {"uri": "file:///etc/hosts"}, "id": 43}`. Which performative and content does the ACL message carry?Apply

An MCP resources/read request for a file uri, and a dashed box asking for the resulting performative and content.

4. In the contract-net demo, worker-a bids price 3 with ETA 18, worker-b price 2 with ETA 25, and worker-c price 4 with ETA 10. The winner has the lowest price plus ETA/10. Who wins?Apply

A three-row table of bidder, price and eta with a note on the scoring formula, and a dashed box asking for the winner.

5. In the demo, the manager sends a cfp to three workers, receives three proposals, then awards one and rejects the rest. How many messages are in the contract-net log?Apply

A manager box, a three-bidders box marked already proposed, and an award box marked one accepted two rejected, with a dashed box asking for the total number of messages in the log. — Typed schematic, not captured output.

6. What happens when code builds `ACLMessage(performative="notify", ...)` with the demo's class?Apply

Code constructing an ACLMessage with performative notify, with a dashed box asking what happens, and a note that sixteen performatives are allowed.

7. What does `a2a_subscribe_to_acl("t-12", "research-host", "code-review-agent").render()` print for the identifying fields?Apply

A call to a2a_subscribe_to_acl for task t-12, and a dashed box asking which identifying fields print and with what values.

8. `main.py` rejects an unknown performative but never inspects `content`. Which failure from the lesson can still slip through?Analyze

The ACLMessage constructor from main.py, with the performative check shown and a comment noting content is typed Any and never inspected, and a dashed box asking which failure can still slip through.

9. You run `main.py` and see a contract-net winner. A teammate wants to ship the same scoring as a production task market. What does the Author's Note say is missing?Analyze

A contract-net demo box, a teammate who wants to ship the same scoring, and a dashed box asking what the Author's Note says a production task market is missing.

Use It

outputs/skill-fipa-mapper.md is a skill that reads an agent-protocol spec and produces the FIPA-ACL mapping. Run it before adopting a new protocol to answer one question: is this genuinely new, or is it inform with JSON syntax?

Check: Use It0/1

1. Your team is evaluating a new agent protocol. What does the `fipa-mapper` skill from the Use It section help you decide?Explain

Ship It

Don't bring FIPA-ACL back. Bring back its checklist:

What is the intent primitive (performative) of each message?
Is there a correlation id for request-response and cancellation?
Is there an explicit content language (JSON-RPC, plain text, structured typed artifact)?
Are interaction protocols first-class, or are you re-implementing contract-net from scratch?
What happens when two agents disagree about content meaning (semantic drift)?

Write these five answers down for any new protocol before it reaches production.

Check: Ship It0/2

1. The Ship It checklist asks whether a protocol has a correlation id. What does that id support?Explain

A caller and a callee exchanging a request and a reply, each carrying an id, with a note about cancelling later and a dashed box asking what the shared id supports. — Typed schematic, not captured output.

2. You are designing the protocol for a new LLM multi-agent system, and someone proposes reviving FIPA-ACL as is. What does the lesson recommend?Design

A proposal to revive FIPA-ACL as is, with a full-revival option and an ignore-it-entirely option, and a dashed box asking what the lesson recommends instead.

Author's Note

I'd run main.py before reading the mapping table. It prints each MCP or A2A message next to its ACL rendering, and seeing tools/call come out as a request with the same seven envelope fields makes the heritage argument concrete in a way the prose can't.

My bet is that the part worth studying is what the code does not check. ACLMessage raises a ValueError if the performative isn't in its set of sixteen, so intent is validated. content is typed as Any and never inspected, so a customer that means two different things sails straight through. That gap is the semantic-drift failure from the body, and the JSON Schema mitigation would slot in right at that boundary.

I'd also keep the toy in proportion. The translators only go one way, JSON to ACL, and the MCP conversation ids are built from the JSON-RPC id by string formatting. The contract-net winner comes from a scoring rule I picked, price plus a tenth of the ETA in minutes, so change the weights and a different bidder wins. Treat the negotiation as a message-flow demo. A real task market needs timeouts, a cancel, and a plan for bidders that never answer, which Exercise 2 starts on with cancel.

Exercises

Run code/main.py. Observe how each message is translated to ACL. Identify which FIPA performative corresponds to tools/call, resources/read, and A2A task creation.
Extend the contract-net demo with a cancel performative that lets the manager withdraw the task mid-bid. What failure case does cancel solve that retries alone do not?
Read FIPA ACL Message Structure (http://www.fipa.org/specs/fipa00037/) sections 4.1–4.3. Pick one performative not covered in this lesson and describe its modern JSON-RPC analog.
Read Liu et al., arXiv:2505.02279. For each of MCP, A2A, ACP, ANP, list the FIPA performative families they keep and drop.
Design a minimal JSON-Schema for the content field of a request performative in your own system. What does that schema give you that pure natural-language does not, and what does it cost?

Key Terms

Term	What people say	What it actually means
Speech act	"An utterance that does something"	Austin/Searle: utterances as actions. The theoretical parent of ACL.
FIPA	"That old XML thing"	IEEE Foundation for Intelligent Physical Agents. Standardized ACL in 2000.
ACL	"Agent Communication Language"	FIPA's envelope format: performative + content + metadata.
Performative	"The verb"	The intent class of a message: `inform`, `request`, `propose`, `cfp`, etc.
KQML	"FIPA's predecessor"	Knowledge Query and Manipulation Language (1993). Simpler, narrower.
Ontology	"Shared vocabulary"	A formal definition of the concepts the content language talks about.
SL0 / SL1	"FIPA content languages"	Semantic Language levels 0 and 1, the formal content language family.
Contract Net	"Task market"	Manager issues cfp; bidders propose; manager accepts. The canonical interaction protocol.
Interaction protocol	"Pattern of messages"	A sequence of performatives with known correctness: request-when, subscribe-notify, etc.