FIPA-ACL Specifications

Reference: Foundation for Intelligent Physical Agents (2002). FIPA ACL Message Structure Specification (FIPA00061) and FIPA Communicative Act Library Specification (FIPA00037). Geneva, December 2002. (FIPA was absorbed into the IEEE Computer Society in 2005; specifications remain the canonical reference.) FIPA00061 (Message Structure) · FIPA00037 (Communicative Act Library) · FIPA00067 (Agent Message Transport) · IEEE FIPA standards committee

Summary

The FIPA-ACL specifications are the standards-track distillation of the late-1990s mentalistic ACL programme: the wire format and semantics that “ended up shipping” as the canonical example of an industry-grade agent communication language. The suite splits into three documents that matter for ACL design. FIPA00061 specifies the message structure — the surface syntax of an ACL message as a parameterised performative envelope with :sender, :receiver, :content, :language, :ontology, :protocol, :conversation-id, :reply-with, :in-reply-to, :reply-by, and a small set of related parameters. FIPA00037 specifies the communicative act library — twenty-two performatives (accept-proposal, agree, cancel, cfp, confirm, disconfirm, failure, inform, inform-if, inform-ref, not-understood, propagate, propose, proxy, query-if, query-ref, refuse, reject-proposal, request, request-when, request-whenever, subscribe) — each given by feasibility precondition (FP) and rational effect (RE) expressed in the FIPA Semantic Language (SL) over beliefs, intentions, and uncertainty. FIPA00067 specifies the message transport (HTTP, IIOP, WAP carriers; envelope and routing).

Two features make FIPA-ACL the canonical reference point — and the canonical negative example — for ACL semantics work. First, the direct lineage from Cohen and Levesque: the FP/RE structure of FIPA00037 is a streamlined adaptation of Cohen and Levesque 1995. The semantics of inform(p) is, modulo notation, exactly the Cohen–Levesque definition: the sender believes p, believes the receiver does not know p, and intends the receiver to come to believe p. The semantics of request mirrors attempt over a hearer action. Second, the unverifiability problem: precisely because the semantics is given in terms of sender and receiver mental states, no external observer can determine whether a message is FIPA-conformant. A platform that ships inform(p) in violation of its feasibility preconditions (e.g. the sender does not believe p, i.e. is lying) is indistinguishable on the wire from a platform that ships a conformant inform. This is the deficiency Singh 1998 names, Wooldridge formalises, and the commitment-based semantics tradition fixes.

For this vault, FIPA-ACL is the engineered artefact against which the public-semantics critique runs. The spec is well-engineered as a message format — the envelope, the protocol-id mechanism, the ontology / language slots are all sound — and the wire format itself has aged well. What has not aged well is the semantics by mental-state precondition: it is unverifiable, hostile to heterogeneous deployment, and incompatible with the public-semantics / commitment-based programme that CBCL inherits. The right reading is: keep the engineering, replace the semantics.

Key Ideas

Three-part suite: FIPA00061 (message structure), FIPA00037 (communicative act library), FIPA00067 (message transport).
Message structure: :sender, :receiver, :content, :language, :ontology, :protocol, :conversation-id, :reply-with, :in-reply-to, :reply-by, :performative. Standard envelope; the :content slot carries an arbitrary content-language expression interpreted by the :ontology.
Twenty-two performatives: from accept-proposal through subscribe, organised loosely into Searlean families (assertives, directives, commissives, declaratives). The set is small enough to remember and rich enough to cover most multi-agent interaction patterns.
Semantic Language (SL): FIPA’s formal language for FP/RE definitions; a modal logic over belief, uncertainty, intention, and action, descended from Cohen and Levesque.
Feasibility precondition / rational effect: each performative is defined by an FP (what must hold for the agent to perform the act in good faith) and an RE (what the agent intends to bring about). Both involve nested beliefs and intentions of sender and receiver.
Interaction protocols: FIPA also standardises a small set of interaction protocols (FIPA-Request, FIPA-Query, FIPA-ContractNet, FIPA-IteratedContractNet, FIPA-EnglishAuction, FIPA-DutchAuction, FIPA-Brokering, FIPA-Recruiting, FIPA-Subscribe, FIPA-Propose) — finite state machines over performatives that script common conversational patterns.
Unverifiability is intrinsic: the FP/RE conditions are stated over mental states; no external observer can check conformance without inspecting agent internals — a known design cost and the central target of the social-agency critique.

Connections

Conceptual Contribution

Claim: A standardised ACL can be built from a small set of performatives, each given by mental-state preconditions and intended effects in a modal logic, embedded in a standardised message envelope, with a standard library of interaction protocols. The result is the canonical industry ACL.
Mechanism: Three coordinated specs. FIPA00061 fixes the wire format (envelope parameters and message routing). FIPA00037 fixes the performative semantics in SL, with each of twenty-two performatives given by FP and RE in terms of belief, uncertainty, and intention nested over sender and receiver. FIPA00067 specifies the message transport. A small library of interaction protocols (FIPA-Request, FIPA-ContractNet, etc.) gives canonical conversational patterns as finite state machines over performatives.
Concepts introduced/used: FIPA Performative, Semantic Language (FIPA SL), Feasibility Precondition, Rational Effect, FIPA Interaction Protocol, ContractNet, ACL Message Envelope, Conversation ID.
Stance: standards specification suite / industry deliverable.
Relates to: Direct standardisation of Cohen and Levesque 1995 — the FIPA00037 semantics is essentially that paper’s framework with editorial smoothing. As the canonical engineering artefact of mentalistic ACL semantics, FIPA-ACL is the negative example for Singh 1998, Wooldridge, Yolum & Singh, Fornara & Colombetti, and the public-semantics tradition generally. CBCL reuses the engineering of FIPA-ACL (typed performative envelope, conversation-id, ontology slot, protocol-id) while replacing the semantics with publicly verifiable commitment-based meaning. The modern LLM-agent protocol generation (Model Context Protocol, Agent-to-Agent Protocol, LACP) has retreated from FIPA’s level of semantic ambition; the open question is whether that retreat will repeat the mentalistic mistake under a new guise (sycophantic JSON tool-calls) or learn from the FIPA experience.

Tags

#fipa #acl #standard #mentalistic-semantics #performatives #classical-acl #message-envelope #specification

Backlinks

Linked Pages

LACP

LLM-Agent Communication Protocol — a proposed three-layer, telecom-inspired standard for inter-agent communication. Layers: Semantic (universal PLAN/ACT/OBSERVE/ERROR messages), Transactional (JWS signing, transaction IDs, two-phase commit, idempotency), Transport (HTTP/2, QUIC, WebSockets). Built on the Narrow Waist Principle with security-by-construction.

Discussed in:

LLM Agent Communication Protocol Requires Urgent Standardization

Agent-to-Agent Protocol

A2A — protocol for inter-agent communication among autonomous LLM agents.

Discussed in:

Model Context Protocol

MCP — an open protocol (Anthropic, 2024) standardising how LLM applications connect to external tools and data sources.

Discussed in:

CBCL - Safe Self-Extending Agent Communication

CBCL: Safe Self-Extending Agent Communication

Reference: O’Connor, H. (2026). LangSec Workshop, IEEE Security and Privacy Workshops (SPW 2026). arXiv:2604.14512v1 [cs.CR], 16 Apr 2026. Source file: oconnor-cbcl-langsec26.pdf. URL. Reference implementation: https://codeberg.org/anuna/cbcl-rs.

Summary

Building on McCarthy’s 1975/1982 Common Business Communication Language vision and the language-theoretic security programme of Sassaman, Patterson, Bratus and Locasto (Security Applications Of Formal Language Theory), this paper presents a contemporary CBCL: an agent communication language designed so that all messages — including runtime language extensions — remain within the deterministic context-free (DCFL) complexity class. The motivating diagnosis is that contemporary agent communication has slid up the Chomsky hierarchy without acknowledging the security cost: KQML and FIPA-ACL are CFL with informal extensibility, but MCP and LLM-based agent frameworks operate over inputs whose effective complexity is recursively-enumerable, where the validity of an arbitrary message is undecidable and “weird machines” (Exploit Programming - From Buffer Overflows To Weird Machines) become unavoidable. CBCL takes the opposite tack: minimal core (8 performatives — tell, ask, reply, hello, bye, ok, error, cancel) plus a homoiconic dialect mechanism that lets agents define, transmit, and adopt domain-specific vocabularies as first-class CBCL messages, with three machine-checked safety invariants — R1 (no recursion in dialect templates), R2 (declared resource bounds on depth, expansion size, verification time), R3 (core-vocabulary preservation) — that together guarantee DCFL preservation under arbitrary finite sequences of dialect installations.

The paper accompanies the design with a Lean 4 formalization (≈5,400 lines, 16 modules, 176 machine-checked theorems, zero sorry gaps, no custom axioms) covering parser correctness (soundness + completeness), R1–R3 verification, pipeline totality, and the central dcfl_preserved closure theorem; a verified parser binary cbcl-parse is extracted from the proofs. A separately-developed Rust reference implementation (cbcl-rs, ≈11,000 lines, no_std-compatible core) ships a hand-rolled O(n) parser, dialect verification engine, gossip-based dialect propagation (O(log n) convergence per Demers et al.), C FFI/WASM bindings, property-based and differential tests, and cargo-fuzz targets; differential tests cross-validate the Rust parser against the Lean-extracted binary, eliminating spec-implementation parser differentials. Five example dialects (precision agriculture, AI planning, cross-chain asset transfer, artifact management, email) are R1–R3-verified end-to-end. A draft IETF Internet-Draft specifying application/cbcl and a Nostr transport binding (cbcl-nostr) accompany the paper. The Discussion explicitly aligns the design with Singh’s social-agency programme: dialect installation is treated as a public commitment to the dialect’s declared semantics — semantic divergence becomes a breach of commitment, observable and accountable, rather than a hidden failure of shared mental state — sidestepping the unverifiable mentalistic semantics critique of Verifiable Semantics for ACLs.

Implementation status (post-paper, cbcl-rs). The reference implementation has shipped two further safety invariants the paper sketches as future work, plus a richer Lean formalisation: R4 (Integrity) — Ed25519-style signatures over canonical encodings via an algorithm-agnostic Signer trait, with three-valued install verdicts (Valid / Unsigned / Invalid) — and R5 (Contract Well-formedness) — optional (protocol …) and (shape …) clauses on a dialect, expressing causal Merkle DAG protocols and per-performative shape contracts; R5 enforces acyclicity, reachability from begin, performative definedness with ancestor closure for extends, step uniqueness, and depth-bound respect, all decidable in linear fuel at install time. The §VII-D structural-contracts vision is therefore live (SPEC-002, SPEC-003): verify_monotone, verify_all_is_meet, and verify_eventually_consistent are proved theorems showing causal-protocol verification is a lattice homomorphism that joins coordination-free under G-Set store merge — explicit CALM Theorem alignment. The Lean codebase has grown to 380+ declarations across 19 files (still zero sorry, only the standard axioms propext / Classical.choice / Quot.sound); the workspace ships 837 tests including 584 cbcl-core unit tests, 37 proptest cases, 21 differential integration tests against the Lean-extracted binary, libFuzzer harnesses, and cargo-mutants mutation testing at a 90% kill threshold. The crate layout has grown from the paper’s five to seven: the original cbcl-core / cbcl-parser / cbcl-cli / cbcl-wasm / cbcl-ffi plus cbcl-erl (Erlang/LFE binding, SPEC-009 — with SPEC-010 binding-conformance suite) and cbcl-arena (Agent Arena platform, SPEC-012 — composable referee on cbcl-lfe-router with capability-keyed message routing and signed receipt logs). A worked sealed-bid auction dialect (SPEC-004) demonstrates structural defence against false-claim manipulation — concrete evidence that the R5 contract layer is rich enough to encode mechanism-design integrity properties decidably. The earlier Scheme prototype (anuna-research/cbcl) is superseded; architecture decisions live as ADRs under .hence/ (purity boundary, parser library choice, error handling, WASM API surface, R4 adversarial review).

Key Ideas

DCFL as the Goldilocks complexity class: Regular is too weak for nested envelopes/dialects; general CFL admits ambiguous grammars and parser-differential attacks; context-sensitive is PSPACE-complete; Type-0 is undecidable. DCFL is the minimal class that supports nested structure with class-level unambiguity (parser equivalence under language evolution).
Homoiconic self-extension: Dialect definitions are themselves valid CBCL messages, parsed by the same recogniser used for ordinary communication — a single attack surface, no separate meta-language. Inspired by Racket’s #lang mechanism.
Three safety invariants R1–R3: declarative pattern-template substitution only (no recursion, no iteration, no reflection); declared resource bounds (depth ≤ 64, expansion ≤ 8192 chars, verification ≤ 1000 ms); the eight core performatives cannot be redefined.
DCFL preservation theorem: dialect invocations must appear inside a (lang name …) wrapper; the lang tag plus a unique dialect name forms a prefix-free partition that lets a deterministic pushdown automaton dispatch to the appropriate subgrammar without extra lookahead — circumventing the fact that DCFLs are not closed under union in general. Mechanised in Lean 4 as dcfl_preserved.
Lean 4 formalization with extraction: 176 theorems, 0 sorry gaps, no custom axioms; the verified parser binary cbcl-parse is extracted from the proofs and runs the same fuel-bounded recursive-descent parser as the model.
Rust reference implementation: cbcl-core (no_std, no unsafe), cbcl-parser, cbcl-cli, cbcl-ffi, cbcl-wasm. Differential tests against the Lean-extracted binary; cargo-fuzz over five entry points.
Eight core performatives (tell, ask, reply, hello, bye, ok, error, cancel) plus four message categories (simple, meta, lang-scoped, wrapped); keyword parameters in Common-Lisp style (:thread, :in-reply-to).
Single-pass template expansion: terminates in time linear in the template plus argument size; not Turing-complete; output is not fed back into the expander, ruling out unbounded re-expansion.
Epidemic dialect propagation: gossip-based with Demers et al.’s O(log n) convergence bound; agents independently verify R1–R3 and signatures before installing.
Canonical serialization per RFC 9804 for cryptographic operations — deterministic byte representation as a precondition for signature verification.
Dialect identity by content hash: name collisions resolved by canonical-form hash; downgrade attacks rejected at installation.
Self-expression vs self-adaptation (Zambonelli et al.): traditional ACLs support only parameter tuning within fixed structure; CBCL is a self-expressive protocol whose vocabulary structurally evolves under safety constraints.
Singh-aligned reading of dialect installation: a public commitment to declared semantics, with :examples clauses providing machine-checkable behavioural anchors — semantic divergence as observable breach rather than hidden mental-state mismatch.
Stated limitations: DCFL ceiling means no recursive transformations, no cross-field references (e.g. checksums over fields), no aggregation over variable-length collections, no context-sensitive validation. Standish-taxonomy paraphrastic only — no Orthophrase, no Metaphrase. Trust infrastructure (key distribution, revocation) and dialect-curation policy left to deployment.
Structural-contracts extension (sketched in §VII-D, shipped post-paper as R4 + R5): Ed25519-style dialect signatures plus protocol constraints as causal Merkle DAGs over performative-typed messages, with Visibly Pushdown Languages for shape constraints and coordination-free monotonic verification over an append-only store. Lean-mechanised lattice-homomorphism theorems (verify_monotone, verify_all_is_meet, verify_eventually_consistent) establish that replica verdicts join under G-Set merge.

Connections

Common Business Communication Language — McCarthy’s 1975/1982 origin; CBCL is the formally-verified realisation of that vision.
Security Applications Of Formal Language Theory — Sassaman et al.’s LangSec foundations.
Proof-Carrying Code - Necula — Necula 1997, the architectural ancestor of CBCL’s R4 split (host runs a small certified verifier; producer ships the proof).
Enforceable Security Policies - Schneider — Schneider 2000, the formal warrant for R5 monotone-verdict trace monitoring.
An Axiomatic Basis for Computer Programming - Hoare — Hoare 1969, root of the contract-based verification line CBCL inherits.
Authentication in Distributed Systems - Lampson Abadi Burrows Wobber — Lampson et al. 1992, the Speaks-For Calculus for delegated commitments.
Articulating Reasons - Brandom — Brandom 2000, the philosophical underwriting of Public Semantics (entry point).
Making It Explicit - Brandom — Brandom 1994, the full inferentialist treatise.
Empiricism and the Philosophy of Mind - Sellars — Sellars 1956, the Myth of the Given that makes Semantics-Without-Minds possible.
Philosophical Investigations - Wittgenstein — Wittgenstein 1953, Meaning As Use / language-games / rule-following.
Two Dogmas of Empiricism - Quine — Quine 1951, Semantic Holism.
Assertion - Stalnaker — Stalnaker 1978, Common Ground update semantics — operational analogue of CBCL’s verdict ledger.
Languages and Language - Lewis — Lewis 1975, Convention of Truthfulness picture of how an abstract language gets in force in a population.
Communicative Actions for Artificial Agents - Cohen Levesque — Cohen & Levesque 1995, the Mentalistic Semantics high-water mark CBCL deliberately is not.
FIPA-ACL Specifications — the engineering of FIPA-ACL (envelope, conversation-id, ontology slot) CBCL inherits; the semantics it replaces.
An Ontology for Commitments in Multiagent Systems - Singh — Singh 1999, the formal commitment ontology CBCL’s dialect contracts instantiate.
Jones-Sergot Normative Systems — Jones & Sergot 1993, the Counts-As Relation that gives wire events institutional meaning under a dialect contract.
Exploit Programming - From Buffer Overflows To Weird Machines — weird-machine analysis CBCL is designed to preclude at the parser layer.
PKI Layer Cake - Kaminsky Patterson Sassaman — concrete parser-differential attacks; CBCL’s class-level unambiguity rules these out at the grammar level.
The Halting Problems of Network Stack Insecurity
A Language-Based Approach To Prevent DDoS
LangSec
KQML as an Agent Communication Language
KQML - A Language And Protocol For Knowledge And Information Exchange
FIPA-ACL
ACL Rethinking Principles — Singh’s social-agency critique that CBCL’s “dialect installation as public commitment” inherits.
Agent Communication Languages - Rethinking the Principles
Verifiable Semantics for ACLs
A Common Ontology Of ACLs
Commitment-based Semantics
The State of the Art in Agent Communication Languages
Trends in Agent Communication Language
Toward Principles for the Design of Ontologies Used for Knowledge Sharing — Gruber’s ontological-commitment principle CBCL inherits.
Some Philosophical Problems from the Standpoint of Artificial Intelligence — McCarthy & Hayes’s representation/computation separation.
Elephant 2000 - A Programming Language Based on Speech Acts — McCarthy’s intra-program speech-act counterpart to CBCL’s inter-organisational vision.
Adjectival Modifiers
S-expression
Homoiconicity
Code as Data
Creating Languages in Racket — Flatt’s #lang mechanism that inspired CBCL’s homoiconic self-extension.
Extensibility in Programming Language Design - Standish
Language Extensibility Taxonomy
Paraphrase
Orthophrase
Metaphrase
Self-Expression
Self-Adaptation Self-Expression Self-Awareness ASCENS
Dialects and Idiolects
Keeping CALM - When Distributed Consistency is Easy — CALM theorem underwriting the forthcoming coordination-free contracts extension.
Visibly Pushdown Languages
MCP Landscape Security Threats And Future Research Directions
Survey Of AI Agent Protocols
Survey Of Agent Interoperability Protocols
ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems — concrete LLM-agent worm whose root-cause analysis CBCL’s lang-scoped provenance addresses.
Why AI Agents Communicate In Human Language
Why Do Multi-Agent LLM Systems Fail
Gossiping in Distributed Systems
Gossip-based Aggregation in Large Dynamic Networks

Conceptual Contribution

Claim: Agent communication languages can be simultaneously expressive, runtime-extensible, and tractably verifiable iff every message — including those that extend the language — is constrained to the deterministic context-free language class; this constraint is compatible with first-class self-extension, can be machine-checked end-to-end, and converts the unverifiable-mental-state problem of mentalistic ACLs into a public-commitment problem at the protocol layer.
Mechanism: Eight-performative core grammar (LL(1), DCFL); homoiconic dialect mechanism — dialect definitions are valid CBCL messages with extend clauses describing pattern-template substitutions; three safety invariants R1–R3 enforced at installation (no recursion via DFS cycle detection, declared resource bounds, core-vocabulary preservation); (lang name …) wrapper providing prefix-free deterministic dispatch into per-dialect sub-grammars so the union remains DCFL. Lean 4 formalization (LeanCbcl, ~5,400 LoC, 176 theorems) covering parser soundness/completeness, R1–R3, pipeline totality, and dcfl_preserved; verified parser extracted to a runnable binary (cbcl-parse). Rust reference implementation (cbcl-rs, ~11,000 LoC) with a ResourceContext-tracked single-pass expander, gossip-based dialect propagation (O(log n) per Demers et al.), canonical RFC-9804 serialization for signing, algorithm-agnostic Signer trait, C FFI / WASM bindings, property-based + differential tests, fuzz targets. Draft IETF application/cbcl Internet-Draft and Nostr transport binding.
Concepts introduced/used: Deterministic Context-Free Language, LangSec, Homoiconicity, S-expression, Dialects and Idiolects, Performatives, Self-Expression, Paraphrase, Orthophrase, Metaphrase, Visibly Pushdown Languages, CALM Theorem, Commitment-based Semantics, Public Semantics, Verifiable Semantics, Adjectival Modifiers, Ontological Commitment, Lean 4, Property-Based Testing, Parser Differential Attack, Weird Machine, Gossip Protocols, Canonical Serialization, Nostr, hence
Stance: engineering / formal-methods, with explicit position-taking on the agent-communication design space
Relates to: Realises McCarthy’s Common Business Communication Language vision (1975/1982) by giving formal safety guarantees McCarthy could only gesture at. Sits squarely in the LangSec programme of Security Applications Of Formal Language Theory and Exploit Programming - From Buffer Overflows To Weird Machines, extending it from input-validation analysis to protocol design — claiming, plausibly, to be the first ACL designed from LangSec principles and the first to demonstrate that LangSec is compatible with runtime self-extension. Inherits the DCFL-vs-ambiguous-CFG argument from PKI Layer Cake - Kaminsky Patterson Sassaman and applies it at the message layer rather than the certificate layer. Builds explicitly on Singh’s social-agency critique (ACL Rethinking Principles) and Wooldridge’s verifiability programme (Verifiable Semantics for ACLs) by treating dialect installation as a public commitment whose semantics are anchored by the :examples clause — a machine-checkable analogue of the commitment-trace conformance that Flexible Protocol Specification and Execution (Yolum & Singh) and Commitment Machines - Yolum and Singh establish for protocol actions. Where Pact - A Choreographic Language for Agentic Ecosystems takes the individual-rationality fork to answer “why follow a protocol?”, CBCL takes the publicness/verifiability fork: the meaning of a message is fully determined by the formal grammar plus declared semantics, with no mental-state inference required. Inherits Gruber’s ontological-commitment architecture but replaces “out-of-band agreement” with in-protocol propose/query/teach. The extensibility design draws on Creating Languages in Racket (Flatt’s #lang) and respects the boundary set by Extensibility in Programming Language Design - Standish: paraphrastic only, deliberately excluding orthophrase/metaphrase to keep the attack surface bounded. The forthcoming structural-contracts extension uses Visibly Pushdown Languages for shape constraints and the CALM Theorem for coordination-free verification — a natural bridge to commitment-machine semantics. The LLM-agent threat-model framing (ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems, MCP Landscape Security Threats And Future Research Directions) positions CBCL as the structural alternative to MCP/JSON-RPC-with-natural-language: same extensibility, vastly tighter security envelope.

Public Semantics

ACL semantics grounded in externally observable facts (commitments, roles, institutional state) rather than private mental state.

In this vault

ACL Rethinking Principles
Agent Communication And Institutional Reality
Commitment-based Semantics
Mentalistic Semantics
CBCL - Safe Self-Extending Agent Communication — dialect installation as a public commitment

A Commitment-Based Approach to Agent Communication

Reference: Fornara, N. & Colombetti, M. (2004). Applied Artificial Intelligence 18(9–10): 853–867. DOI: 10.1080/08839510490509054. The journal article is paywalled; the open-access AAMAS-02 conference precursor — Operational Specification of a Commitment-Based Agent Communication Language (pp. 535–542) — captures the same model and is the locally archived source. Source file: fornara-colombetti-aamas02.pdf. URL

Summary

Fornara and Colombetti develop an object-oriented operational semantics for an Agent Communication Language grounded entirely in social commitments, intended for open environments populated by self-interested, heterogeneous agents who cannot be assumed to share an honest mental architecture. A Commitment is an abstract data type with fields Identifier, Debtor, Creditor, State ∈ {empty, cancelled, precommitment, conditional, active, fulfilled, violated}, Content (a temporal proposition), Condition (another temporal proposition), and Time-out. Its evolution is given by an explicit finite-state machine driven by two kinds of transitions: agent-invoked methods (mc, mp, ap, cc, cp, rp) and event-driven update rules triggered when the truth value of the content or condition resolves.

The authors’ key innovation over the Yolum-Singh treatment is the precommitment state, which models the social situation a directive speech act creates: the speaker cannot directly commit the hearer, so a request instantiates a precommitment whose debtor is the hearer; the hearer either accepts it (turning it into an active or conditional commitment), rejects it, fulfills it implicitly by performing the action, or lets the time-out elapse. This machinery yields uniform commitment-based definitions for Searle’s main illocutionary categories — assertives (inform, informIf, informRef), commissives (promise, conditionalPromise), and directives (request, conditionalRequest, accept, reject, yes/noQuestion, whQuestion) — and lets a propose act be defined compositionally as a conditional request conjoined with a conditional promise. A worked auction-style proposal protocol is given as an interaction diagram whose state contents are computed from the speech-act definitions, and whose soundness is checked by requiring that all final-state commitments be empty, fulfilled, or violated.

Key Ideas

Commitment-as-object: a commitment is an abstract data type with a state in {e, c, p, cc, a, f, v} whose dynamics are described by an explicit FSM.
Temporal proposition class: the content/condition of a commitment is a sentence + time interval + ∀/∃ mode + state, resolved by a domain “notifier” — separating what is committed from when and how its truth is observed.
Precommitment models directive speech acts: a request creates C(p, hearer, speaker, P|Q) that the hearer can accept (ap), reject (rp), implicitly fulfil (update rule 5), or let time out.
Conditional commitment with a temporal condition becomes active when the condition is satisfied and is automatically cancelled if the condition fails.
Five update rules link the truth-state of content and condition propositions to commitment-state transitions (active→fulfilled/violated, conditional→active/cancelled, precommitment→fulfilled).
Searle’s taxonomy of illocutionary acts is recovered by composition: inform, promise, request, accept/reject, yes/noQuestion, whQuestion, propose.
Soundness of an interaction protocol is checked by an interaction diagram in which every final state’s commitments are empty, fulfilled, or violated — a structural correctness criterion for negotiation protocols.
The notion of a conversational commitment (a meta-commitment to react to interlocutor speech acts) is sketched as the principled justification for the time-out field.

Connections

Conceptual Contribution

Claim: Speech-act semantics for an ACL should be specified operationally — as state-machine transitions over a public commitment data type — so that meaning is independent of any agent’s internal mental architecture, observable to third parties, and compositional across the speech-act taxonomy; in particular, the directive family requires a dedicated precommitment state because no agent can unilaterally commit another.
Mechanism: Define an abstract Commitment class with seven explicit states and a transition FSM driven by methods (mc/mp/ap/cc/cp/rp) plus five event-driven update rules that read truth-states of Temporal Proposition objects; define each Searle category by a single-line operation on commitment objects (inform := mc(a,b,P,T), request := mp(a,b,P,T), propose := conditionalRequest ∧ conditionalPromise, etc.); validate interaction protocols structurally via a state-content interaction diagram in which final-state commitments must all be empty/fulfilled/violated.
Concepts introduced/used: Commitment, Social Commitment, Precommitment, Conditional Commitment, Temporal Proposition, Commitment-Based Protocol, Commitment-based Semantics, Public Semantics, Verifiable Semantics, Speech Act Theory, Directives, Conversation Protocols, Interaction Protocols, Open Multi-Agent Systems, Conversational Commitment
Stance: formal-semantic / engineering
Relates to: Closest neighbour is Flexible Protocol Specification and Execution (Yolum & Singh, AAMAS-02) — the authors explicitly compare the two approaches: where Yolum-Singh use the Event Calculus and an abductive planner over create/discharge/cancel/release/assign/delegate, Fornara-Colombetti use an OO/FSM data type and add the precommitment apparatus to cover directives. Both belong to the social-semantics programme catalysed by ACL Rethinking Principles and formalised verifiability-style by Verifiable Semantics for ACLs; both are subsumed under the role-based unification of A Common Ontology Of ACLs. Repudiates the mentalistic line of FIPA-ACL / Intention Is Choice with Commitment for interoperable ACL semantics while keeping speech-act theory (Speech Acts - An Essay in the Philosophy of Language, A Taxonomy of Illocutionary Acts) as the organising taxonomy. The 2004 Applied AI version this entry primarily cites elaborates the AAMAS-02 model with extended treatment of negotiation protocols and the soundness-via-conversational-commitment programme that the authors’ later artificial-institutions work develops.

Tags

Commitment Machines - Yolum and Singh

Commitment Machines

Reference: Yolum, P. & Singh, M.P. (2002). Intelligent Agents VIII: Agent Theories, Architectures, and Languages (ATAL-01), LNAI 2333, pp. 235–247. Springer. (A preliminary version appeared in WET-ICE 2000.) Source file: yolum-singh-2002-commitment-machines.pdf. URL

Summary

Yolum and Singh propose commitment machines (CMs) as a protocol formalism that, unlike finite-state machines or Petri nets, attaches declarative meaning to states and actions in terms of the participants’ Social Commitments. A CM is a triple ⟨M, Δ, F⟩ of a finite minimal set of meanings (formulas in a propositional language extended with a commitment operator Cₓp and a strict-implication operator ;), a set of actions ⟨a : e⟩ whose effect e is itself a meaning, and a set of consistent final meanings. Transitions are not enumerated — they are inferred from the logical consequences of applying an action’s effect to the current meaning. The running example is the NetBill Protocol, specified by atomic propositions (request, goods, pay, receipt) and abbreviations for conditional commitments (accept = C_c(goods ; pay), promiseGoods = C_m(accept ; goods), etc.); three reasoning rules govern how commitments evolve as content propositions are made true.

The paper’s central technical contribution is a compilation procedure that turns any complete CM (one whose meaning set is closed under antecedence) into a deterministic FSM that can be executed in constant space without commitment reasoning at run time. The procedure is shown sound (Theorem 2 — every realised computation is generated by the source CM) and complete (Theorem 3 — every CM-generated computation has a semantically-strongest, efficient FSM-realised counterpart from true), via a chain of lemmas about semantic superiority, efficient computations, and endpoint equivalence. Because the meanings of states are explicit, agents executing the CM directly can plan paths through the protocol that exploit opportunities (e.g. a merchant proactively quoting without a request, “try before you buy” deals) and handle exceptions, recovering autonomy that pure-token FSM/Petri-net specifications eliminate.

Key Ideas

Commitment machine ⟨M, Δ, F⟩: state space is a finite minimal set of meanings (formulas) rather than tokens; actions ⟨a : e⟩ carry effect-meanings; final states are a consistent subset of meanings.
Inferred transitions: q ⊨_⟨a:e⟩ r iff (q ∧ e) ⊢ r — transitions are derived from logical entailment, not enumerated edges.
No fixed start state: a CM has no s₀; participants may begin from any meaning whose commitments they accept (typically true).
Three reasoning rules over commitments: (1) Cₓp discharges when p holds; (2) Cₓ(p ; r) collapses to base-level Cₓr when p holds; (3) Cₓ(p ; r) ceases when r holds before p, with no new commitment.
Compilation to deterministic FSM under two restrictions: (R1) no transition mᵢ → mⱼ if mᵢ ⊢ mⱼ (no information-free moves); (R2) the target meaning must dominate all alternatives entailed by the action (forcing maximal information).
Completeness requires “complete” CMs — meaning set closed under antecedence — so that a unique strongest target meaning always exists; trivially achieved by closing under conjunction.
Soundness, completeness, determinism established as theorems over the computation abstraction (sequences of meanings interleaved with actions); computations are compared by semantic superiority and endpoint equivalence rather than literal action-sequence equality.
Flexibility recovered for free: since states encode meanings, agents can skip steps, reorder, or take unsolicited shortcuts whenever the resulting meaning is still in M and the path to a final meaning still exists.

Connections

Conceptual Contribution

Claim: Multi-agent protocols should be specified by giving states and actions declarative meaning in terms of the participants’ commitments — not by enumerating legal token sequences — and any such specification can be soundly and completely compiled to a deterministic FSM, recovering executability without forfeiting flexibility, autonomy, or the ability to handle exceptions and exploit opportunities.
Mechanism: A propositional language with a commitment operator Cₓ and strict-implication ;; meaning sets M and final-meaning sets F (consistent w.r.t. logical consequence); action effects given as meanings; transitions inferred via (q ∧ e) ⊢ r. Compilation Procedure 1 maps ⟨M, Δ, F⟩ → ⟨S=M, Σ={a}, s₀=true, Q=F, δ⟩ under the two information-monotonicity restrictions; Procedure 2 promotes a computation to its semantically strongest counterpart, Procedure 3 removes redundant self-transitions, yielding efficient semantically-strongest computations that are realised by the compiled FSM. Soundness (Thm 2), determinism (Thm 1), and completeness for complete CMs (Thm 3) are proved.
Concepts introduced/used: Commitment Machines, Commitment-Based Protocol, Commitment-based Semantics, Conditional Commitment, Social Commitment, Public Semantics, Verifiable Semantics, NetBill Protocol, Endpoint Projection (structural analogue), Conversation Protocols, Speech Act Theory
Stance: formal-semantic / engineering
Relates to: Direct precursor and structural sibling of Flexible Protocol Specification and Execution (Yolum & Singh, AAMAS-02), which lifts the same six commitment operations (Create / Discharge / Cancel / Release / Assign / Delegate) into the Event Calculus and adds an abductive planner; ATAL-01 here is the FSM-compilation half of that programme. Companion to A Commitment-Based Approach to Agent Communication (Fornara & Colombetti, AAMAS-02 / AAI-04), which gives an OO/FSM operational semantics for the same primitives plus a precommitment state for directives. Carries forward the social-agency programme of ACL Rethinking Principles (Singh 1998) and answers Wooldridge’s challenge in Verifiable Semantics for ACLs by grounding meaning in publicly-observable commitment formulas rather than agent mental state. The Discussion explicitly contrasts with Smith et al.’s joint-intention–based protocols (mental constructs vs. social constructs) — the same fork that Intention Is Choice with Commitment anchors on the mental side. Structurally a direct analogue of choreographic Endpoint Projection: both compile a globally-specified protocol artefact to a per-role executable, the CM/FSM compilation losing declarative meaning for runtime efficiency much as endpoint projection loses the global view for distributable execution. This makes ATAL-01 the load-bearing reference for the constructive synthesis suggested in the Pact - A Choreographic Language for Agentic Ecosystems entry — choreographies could carry both communication structure (Pact-side) and a CM-style commitment trace (Singh-side), with one compilation step yielding both deadlock-freedom and conformance-checkability.

Tags

Verifiable Semantics for ACLs

Verifiable Semantics for Agent Communication Languages

Reference: Michael Wooldridge (1998). ICMAS-98 (International Conference on Multi-Agent Systems). Source file: icmas98.pdf. URL

Summary

Wooldridge tackles a central problem for ACL standardization: how can an external observer verify that an agent conforms to an ACL’s semantics when semantics are expressed in modal BDI logic (beliefs, desires, intentions)? He formalizes an agent communication framework as a tuple containing agent programs, local states, a communication language, a semantic language, and interpretation functions, and defines precisely what it means for a framework to be verifiable: whether one can decide, from program text alone, that the semantic conditions for a sent message are satisfied.

He shows that KQML and FIPA-97 ACL, which define the “sincerity condition” for an inform act using multi-modal quantified logics like SL, are not practically verifiable — deciding whether an agent program really believes what it says requires checking undecidable properties. In contrast, he gives two example frameworks with verifiable (even co-NP-complete) semantics by grounding meaning in program states rather than unobservable mental attitudes. The paper’s upshot: practical ACL conformance testing requires public, state-based semantics.

Key Ideas

Formal agent communication framework as a 2n+4 tuple.
Verifiability = decidability of semantic conformance from program text.
KQML and FIPA-97 semantics (SL modal logic) are not practically verifiable.
Grounding semantics in program states yields co-NP-complete verifiability.
Motivates social/public commitment-based ACL semantics.

Connections

KQML
FIPA-ACL
Speech Act Theory
Agent Communication Languages
Verifiable Semantics
Public Semantics
Commitment-based Semantics
Mental State
Mentalistic Semantics
BDI
CBCL - Safe Self-Extending Agent Communication — O’Connor 2026: a verifiable ACL grounded in DCFL grammars and Lean-checked safety invariants, answering Wooldridge’s challenge in the LLM-agent era.

Conceptual Contribution

Claim: An ACL standard is only useful if one can check whether an implementation respects it; existing ACLs (KQML, FIPA-97) whose semantics are given in multi-modal BDI logics are not practically verifiable, so ACL semantics should instead be grounded in program states.
Mechanism: Formalises an agent communication framework as a (2n+4)-tuple of agent programs, local states, communication language L_C, semantic language L_S, and interpretations; defines verifiability as decidability (in polynomial time) of whether an agent program respects a message’s semantic precondition; shows FIPA’s SL semantics undecidable; constructs two verifiable example frameworks (classical propositional logic, grounded propositional epistemic logic) with co-NP-complete verification.
Concepts introduced/used: Verifiable Semantics, Agent Communication Framework, Sincerity Condition, Grounded Semantics, Program Semantics, Model Checking, BDI Logic, Mentalistic Semantics
Stance: formal-semantic / critique
Relates to: Formal companion to ACL Rethinking Principles — Singh’s social-agency argument becomes Wooldridge’s verifiability theorem. Undermines the semantic ambitions of KQML Overview and FIPA-ACL; motivates commitment-based approaches such as Agent Communication And Institutional Reality and the program-grounded framework in Foundations Of Illocutionary Logic.

Tags

ACL Rethinking Principles

Agent Communication Languages: Rethinking the Principles

Reference: Munindar P. Singh (1998). IEEE Computer, December 1998, pp. 40-47. Source file: computer-acl-98.pdf. URL

Summary

Singh surveys the state of Agent Communication Languages (ACLs) such as KQML and FIPA/Arcol, and argues that their dominant mental-agency semantics (defining communicative acts in terms of beliefs and intentions) is conceptually unsatisfying and practically untestable because we cannot read agents’ minds. He proposes a conceptual shift to social agency: ACL semantics should be grounded in a public perspective on commitments, roles, and societies, so compliance with the standard is observable and testable.

The paper maps the ACL design space along two critical dimensions — meaning (perspective, type, basis, context, coverage of communicative acts) and agent construction (design vs. execution autonomy) — and shows how both KQML and Arcol emphasize private, mental-state semantics and thus fail to enable true heterogeneous interoperation. Singh’s alternative emphasizes protocols, roles, and “society management” infrastructure as a richer public substrate for ACLs.

Key Ideas

Mental-agency ACL semantics (KQML, Arcol, early FIPA) cannot be verified without inspecting agent internals.
ACLs need a public perspective, conventional meaning, pragmatics, and full coverage of communicative act categories.
Seven categories of communicative acts: assertives, directives, commissives, permissives, prohibitives, declaratives, expressives.
Social agency replaces BDI with commitments, roles, and societies as the semantic basis.
Dialects/idiolects arise when only private perspectives are considered.

Connections

FIPA-ACL
FIPA-ACL Specifications
KQML
Speech Act Theory
Agent Communication Languages
Multi-Agent Systems
Communicative Actions for Artificial Agents - Cohen Levesque — the Mentalistic Semantics high-water mark Singh is critiquing
An Ontology for Commitments in Multiagent Systems - Singh — Singh’s own formal sequel: the four-place commitment ontology
Commitment Machines - Yolum and Singh
A Commitment-Based Approach to Agent Communication
Articulating Reasons - Brandom — the philosophical underwriting of public, commitment-based semantics
Making It Explicit - Brandom
Jones-Sergot Normative Systems — Counts-As Relation for institutional grounding of commitments
CBCL - Safe Self-Extending Agent Communication — O’Connor 2026: contemporary realisation of Singh’s social-agency programme (dialect installation as public commitment) in a Lean-verified LangSec-grounded ACL.

Conceptual Contribution

Claim: Agent Communication Language semantics must abandon mental agency (beliefs/intentions) and be grounded in a public, social perspective (commitments, roles, societies) in order to be testable and support heterogeneous interoperation.
Mechanism: Surveys KQML, Arcol, FIPA; lays out a two-dimensional design space (meaning × agent construction); shows that mental-state semantics cannot determine compliance; proposes social-agency framework using protocols, roles, and “society management” infrastructure.
Concepts introduced/used: Mentalistic Semantics, Public Semantics, Social Agency, Commitments, Communicative Acts, Verifiable Semantics, Interoperability, Dialects and Idiolects
Stance: critique / foundational
Relates to: Direct antecedent to Verifiable Semantics for ACLs (Wooldridge) which formalises the verification problem Singh names. Sharpens the critique of the mentalistic approach underlying KQML Overview and FIPA-ACL, and motivates commitment-based frameworks such as Agent Communication And Institutional Reality.

Tags

Mentalistic Semantics

ACL semantics in which each message commits the sender’s (and sometimes receiver’s) beliefs and intentions — powerful but unverifiable from outside.

In this vault

Communicative Actions for Artificial Agents - Cohen Levesque

Communicative Actions for Artificial Agents

Reference: Cohen, P. R. & Levesque, H. J. (1995). Communicative Actions for Artificial Agents. In Proceedings of the First International Conference on Multi-Agent Systems (ICMAS-95), San Francisco, June 1995, pp. 65–72. AAAI Press. Reprinted in J. M. Bradshaw (ed.), Software Agents (AAAI Press / MIT Press 1997), ch. 19. URL (AAAI PDF)

Summary

This paper is the high-water mark of mentalistic ACL semantics: the most explicit, systematic statement of the position that an agent communication act is a complex operator on the BDI states of sender and receiver, and that the semantics of an ACL performative is given by feasibility preconditions and rational effects expressed in modal logic over those mental states. Cohen and Levesque extend the Cohen–Levesque 1990 modal logic of intention into a logic of rational action in which speech acts are first-class actions whose definitions are derivable from more basic actions of attempting to bring about a state of affairs, together with assumed Gricean rationality on the part of both agents. The standard FIPA-ACL semantics in the FIPA Communicative Act Library Specification (FIPA00037) is essentially a streamlined adaptation of the Cohen–Levesque framework.

The mechanism is precise. A speech act e performed by speaker s toward hearer h has a feasibility precondition (e.g. s believes p, s believes h does not know p, s intends h to come to know p) and a rational effect (e.g. h believes p because h believes s sincerely informed). The semantics of inform, request, promise, commit, propose, and other performatives are derived by composition from the more primitive attempt: a request is an attempt to bring about that the hearer perform an action and that the hearer believe the speaker wants the action performed; an inform is an attempt to bring about that the hearer come to believe p and to know the speaker believes p; and so on. The framework is mathematically beautiful and ontologically heavy: it requires every speech act to be defined in terms of nested beliefs and intentions of speaker and hearer, often to several levels of nesting.

This is precisely why Singh 1998 writes the Rethinking critique. The Cohen–Levesque definitions are unverifiable in practice: no external observer can check that an agent believed p when it sent inform(p); the inferential web that fixes whether the agent “really” performed an inform speaks entirely about the agent’s mental state, which is exactly the inscrutable thing the protocol participants do not have access to. The paper is therefore the canonical negative example for CBCL and the commitment-based tradition: it shows what a fully worked-out mentalistic semantics looks like, and that shows why the field has had to move on. The right way to read it in 2026 is as the high statement of a coherent but unverifiable position, not as a blueprint to implement.

Key Ideas

Speech act = action on mental states: a communicative act is a complex action whose semantics is given by feasibility preconditions and rational effects expressed over the BDI states of speaker and hearer.
Attempt as the primitive: more elementary than the standard speech-act categories is the action of attempting — an agent attempts an action toward an end if and only if it performs the action with that goal and the belief that the action is the means.
Composition of performatives: standard performatives (inform, request, promise, propose, confirm, agree, refuse) are derived by composing attempt with specific mental-state preconditions and goals.
Sincerity and competence as background assumptions: the rational effects only follow if speaker and hearer are sincere (no lying) and competent (no false beliefs). When these fail, the framework’s predictions silently fail too.
Joint intentions in conversation: extends the 1990 framework with joint intentions — for conversational acts like agreement, both parties acquire a shared intention with mutual belief.
Verifiability is a known cost: the paper acknowledges that the mental-state preconditions are not externally observable; it argues this is the price of a real semantics rather than a behavioural surrogate.
Closest formal ancestor of FIPA: the FIPA-ACL CAL spec (FIPA00037) is a direct adaptation of this framework with light editorial smoothing.

Connections

Conceptual Contribution

Claim: Communicative acts can be given precise semantics by defining them as complex actions on the BDI states of sender and receiver, derived by composition from the primitive notion of attempt under shared rationality assumptions. The semantics of an ACL performative is its feasibility precondition and rational effect, expressed in modal logic over beliefs, goals, and intentions.
Mechanism: Extend the Cohen–Levesque 1990 modal logic of intention with a notion of attempt (an agent attempts an action toward an end iff it performs the action with that goal and the belief that the action serves the goal). Define each standard performative by composition: inform(s,h,p) requires s believes p, s believes h does not know p, s intends h to come to know p; the rational effect is that h comes to believe p by mutual recognition of s’s sincerity. Similar definitions for request, promise, propose, agree, refuse, with joint-intention machinery handling conversational acts.
Concepts introduced/used: Attempt (Cohen-Levesque), Feasibility Precondition, Rational Effect, Mentalistic Semantics, Joint Intentions, Sincerity Condition, Communicative Act Library.
Stance: foundational technical paper / formal-semantics manifesto.
Relates to: The closest formal ancestor of the FIPA Communicative Act Library (FIPA00037) — the FIPA spec is essentially a streamlined adaptation of this framework. It is the negative example against which the public-semantics / commitment-based line defines itself: Singh 1998 argues precisely that the BDI preconditions are unverifiable and that ACL semantics should be grounded in observable social commitments instead. Yolum & Singh 2002, Fornara & Colombetti 2004, and Singh 1999 develop the public alternative. CBCL then operationalises that alternative as a verified, trace-checkable, self-extending wire format — explicitly not what Cohen and Levesque built. The philosophical critique of mentalistic semantics runs deeper, through Sellars / Brandom / MIE — Cohen–Levesque takes mental states as pre-given semantic primitives, which is the move inferentialism rejects.

Conversation ID

(page does not exist)

ACL Message Envelope

(page does not exist)

ContractNet

(page does not exist)

FIPA Interaction Protocol

(page does not exist)

Rational Effect

In FIPA-ACL, the effect a sender of a communicative act intends to bring about in the recipient (e.g. that the hearer come to believe a proposition). Because it concerns private mental state it is unverifiable, and is the principal target of critiques that call for grounded or social semantics.

In this vault

Feasibility Precondition

(page does not exist)

Semantic Language (FIPA SL)

(page does not exist)

FIPA Performative

(page does not exist)

Survey Of AI Agent Protocols

A Survey of AI Agent Protocols

Reference: Yang, Chai, Song, Qi, Wen, Li, Liao, Hu, Lin, Chang, Liu, Wen, Yu, Zhang (2025). arXiv:2504.16736. Source file: 2504.16736v2.pdf. URL

Summary

This survey offers the first comprehensive classification and analysis of emerging AI agent protocols for LLM-based agents. The authors propose a two-dimensional taxonomy: (object orientation) context-oriented vs inter-agent protocols, and (application scenario) general-purpose vs domain-specific, covering MCP, A2A, ANP, ACP, Agora, LMOS, agents.json, LOKA, PXP, CrowdES, and others.

The paper then evaluates these protocols across efficiency, scalability, security, reliability, extensibility, operability, and interoperability, and sketches a forward-looking agenda: protocols should evolve from static to adaptive, from rules to ecosystems, and from mere communication to collective intelligence infrastructure.

Key Ideas

Two-dimensional taxonomy of agent protocols (object orientation x application scenario).
MCP as a universal context-oriented protocol with Host/Client/Server/Resource roles.
Inter-agent layer splits into general-purpose (A2A, ANP, AITP, ACP, Agora) and domain-specific (robot, human-computer, system).
Evaluation across 7 axes; case studies of MCP, A2A, ANP, Agora.
Next-generation protocols need adaptability, privacy preservation, group interaction.

Connections

Conceptual Contribution

Claim: The zoo of emerging LLM Agents protocols can be organised along two orthogonal axes (context-oriented vs inter-agent; general-purpose vs domain-specific), and evaluated on a shared seven-axis rubric.
Mechanism: Builds a taxonomy, then systematically compares Model Context Protocol, Agent-to-Agent Protocol, Agent Network Protocol, ACP, Agora, LMOS, agents.json, LOKA, PXP, CrowdES against efficiency, scalability, security, reliability, extensibility, operability, interoperability, with case studies.
Concepts introduced/used: Model Context Protocol, Agent-to-Agent Protocol, Agent Network Protocol, Agent Communication Languages, LLM Agents, Multi-Agent Systems, Interoperability, Agent Discovery
Stance: survey
Relates to: Shares its subject with Survey Of Agent Interoperability Protocols but takes a broader taxonomic view; its forward-looking “protocols as ecosystems” framing converges with Levels Of Social Orchestration and motivates coordination layers like Ripple Effect Protocol. Historical continuity with KQML and FIPA-ACL is implicit.

Tags

Languages and Language - Lewis

Languages and Language

Reference: Lewis, D. K. (1975). Languages and Language. In K. Gunderson (ed.), Language, Mind, and Knowledge (Minnesota Studies in the Philosophy of Science, vol. 7, pp. 3–35). University of Minnesota Press. Reprinted in Philosophical Papers Volume I (Oxford UP 1983). URL (Minnesota Digital Conservancy)

Summary

“Languages and Language” is Lewis’s mature statement of the distinction between a language (an abstract function from sound-and-sign types to meanings, with no users) and language (a social phenomenon: a population’s practice of using a particular abstract language to communicate). The paper sharpens the framework introduced in Convention (1969) and rebuts an objection from Strawson and Searle that an account of language as convention — solving a coordination problem by mutual expectation — misses the normative heart of meaning. Lewis answers: it does not. A population uses an abstract language L iff there prevails in that population a convention of truthfulness and trust in L — a regularity by which speakers utter sentences of L only when they believe them true-in-L, and hearers respond by coming to believe the sentences uttered are true-in-L. The regularity is a convention in the technical Lewis 1969 sense: it solves a coordination problem (mutual intelligibility), it is sustained by mutual expectation (common knowledge that it is so sustained), and it has alternatives (some other abstract language could have played the same role).

The paper’s value over Convention is its precise account of the language–language relation. The abstract object L is a function from finite strings to truth-conditions (or, for non-declarative moods, to satisfaction-conditions). The social object — language — is the convention of truthfulness and trust in L. Different populations use different Ls; the same population can use several Ls for different domains. Meaning is not primarily a property of individual speakers’ minds: it is a property of the convention, fixed once we identify which L the population’s convention picks out. Speakers’ beliefs and intentions enter only via the convention-sustaining clauses (each speaker expects the others to be truthful-in-L and tries to be so themselves), not as the bearers of meaning.

For agent communication, “Languages and Language” is the cleanest philosophical statement of the public-semantics programme avant la lettre. The meaning of a wire-format performative is not the BDI state of the sender or receiver; it is the truth- or satisfaction-conditions assigned by the abstract language the protocol convention picks out. Two agents using FIPA-ACL are participating in a convention of truthfulness and trust in the abstract language defined by FIPA-ACL’s semantics. The convention requires only that agents act as if truthful-in-L; it does not require introspective access. This is exactly the dialect-and-protocol picture that Singh 1998 argues for, that commitment machines formalise, and that CBCL turns into a verified, self-extending wire format. Lewis 1975 is also the philosophical complement to Convention: where the 1969 book establishes the game-theoretic apparatus, the 1975 paper applies it to language and shows how to answer the standard objections from the speech-act tradition.

Key Ideas

Two senses of “language”: an abstract language L is a function from sentence-types to meanings (truth- and satisfaction-conditions); language (no article) is the social phenomenon — a population’s use of some L. Confusing the two is the source of much philosophy of language.
Convention of truthfulness and trust: a population uses L iff it has a convention (in the 1969 sense) of truthfulness in L (utter sentences only when believed true-in-L) and trust in L (hearers respond to such utterances by coming to believe the sentences true-in-L).
Meaning is a property of the convention, not the speaker: the convention picks out which L is in force; the meaning of a sentence in that population’s language is its meaning in L. Individual speaker mental states enter only as the conformity conditions of the convention.
Coordination problems and alternative languages: many abstract Ls could solve the population’s coordination problem; salience, precedent, and history pick one. Meaning is not arbitrary in function but contingent in particulars.
Reply to Strawson/Searle: the objection that convention-based accounts cannot capture the normative dimension of meaning is misplaced — the convention is itself a normative structure (it requires mutual expectation and conformity to be in force).
Multiple languages, one population: a population may use several Ls simultaneously — formal and informal registers, technical sub-languages, jargon — each sustained by its own convention.
Sentence moods and non-declaratives: imperatives and interrogatives are handled by extending the abstract L to assign satisfaction- and answerhood-conditions; the convention-of-truthfulness-and-trust generalises to a convention of acting as if the satisfaction-conditions held.

Connections

Conceptual Contribution

Claim: Sharpen the Convention 1969 picture into a precise account of how an abstract language L (a function from sentences to truth-/satisfaction-conditions) gets in force in a population: by a convention of truthfulness and trust in L. Meaning is a property of the convention, not of individual speakers’ mental states.
Mechanism: Define abstract languages as functions from sentence-types to truth- and satisfaction-conditions. Define use of L by population P as the prevalence in P of a convention (in the Lewis 1969 sense) of being truthful in L and trusting in L. Show how this answers Strawson’s and Searle’s normativity objection (the convention is itself normative) and how it generalises to non-declarative moods (satisfaction-conditions) and to populations using multiple Ls.
Concepts introduced/used: Abstract Language, Convention of Truthfulness, Convention of Trust, Truthfulness and Trust, Sentence Mood, Pragmatic Presupposition, Public Semantics.
Stance: foundational philosophical paper.
Relates to: Direct sequel to Lewis 1969 (Convention) — the 1969 book gives the game-theoretic foundations, the 1975 paper applies them to language. Operational complement to Stalnaker 1978: where Stalnaker gives the update mechanics of assertion, Lewis 1975 says what makes a particular abstract language the one the participants are updating in. For agent communication, this is the cleanest philosophical statement of the public-semantics programme: the meaning of an ACL performative is fixed by the protocol convention’s chosen L, not by speakers’ BDI states — exactly the picture Singh 1998 argues for, commitment machines formalise, and CBCL turns into a verified wire format. The view also locates Wittgensteinian meaning-as-use within an explicit game-theoretic setting (Lewis’s convention is the formal regulariser of Wittgenstein’s language-games), and is compatible with Brandomian inferentialism as a downstream layer (inferential articulation is what gives L its truth-conditions in the first place).

Articulating Reasons - Brandom

Articulating Reasons: An Introduction to Inferentialism

Reference: Brandom, R. B. (2000). Articulating Reasons: An Introduction to Inferentialism. Harvard University Press. Based on the 1998 Locke Lectures (Oxford). URL · SEP entry on inferentialism

Summary

Articulating Reasons is the compact entry point to Brandom’s inferentialist programme — a semantics without minds in which the meaning of a sentence is its role in the inferential practices of a community of speakers, rather than a mental representation of how things stand or a Tarskian truth-condition fixed by reference. Where representationalism takes reference and truth as basic and explains inference downstream, Brandom inverts the order: the basic semantic fact is which moves count as good reasons for which other moves, and reference, truth, and propositional content are explained as features of discursive practice downstream of inferential articulation. The slogan is meaning is use, descended from Wittgenstein and Sellars, but Brandom upgrades it from a regulative idea into a worked-out pragmatist semantics.

The mechanism is a deontic scorekeeping account of assertion. To assert something is to undertake a commitment and to license other speakers to attribute that commitment back; the score every speaker keeps on every other is a record of which commitments are undertaken, which are licensed, and which are incompatible. The content of a claim is then exhaustively determined by the inferential articulation of those commitment relations: what entitles you to claim it, what it entitles you to claim, what claims it is incompatible with. The book unfolds this through six lectures — Toward an Inferentialist Semantics, Action / Reason / Inference, Insights and Blindspots of Reliabilism, What Are Singular Terms?, A Social Route from Reasoning to Representing, and Objectivity and the Normative Fine Structure of Rationality — extracting the spine of the 700-page Making It Explicit in a form readable in a week. The view explicitly avoids smuggling in mentalism: there are no beliefs or intentions in the foundations, only the public, trace-checkable practice of giving and asking for reasons.

For agent communication, inferentialism is the philosophical underwriting of the public-semantics programme: it shows that you can have a full theory of meaning — not just a thin behavioural sketch — without ever quantifying over mental states. Singh’s critique of FIPA-style mentalism gestures at this; Brandom delivers the goods. The natural pairing in this vault is with CBCL and the commitment-based semantics of Singh, Fornara, and Colombetti, all of which can be read as engineering realisations of Brandom’s deontic scorekeeping at wire-format granularity.

Key Ideas

Inferentialism: meaning is fixed by inferential role — what claims entitle a speaker to make, what they exclude, what claims entitle the speaker to make them — not by reference or truth-conditions, which are explained downstream.
Deontic scorekeeping: a speaker’s discursive score is the record of which commitments they have undertaken, which entitlements they have, and which incompatibilities apply. Assertion = undertaking a commitment + licensing attribution back to oneself.
Material vs formal inference: inferences like “Pittsburgh is west of Princeton, therefore Princeton is east of Pittsburgh” are materially good — their goodness is part of the meaning of west and east, not a downstream consequence of logical form plus reference.
Logical vocabulary is expressive, not constitutive: connectives like “if … then …” let speakers make explicit, in the form of claims, inferential commitments that were previously only implicit in practice. Logic is the technology for making practices explicit, not the foundation.
Sapience vs sentience: what distinguishes language-users from thermostats is participation in the game of giving and asking for reasons. No phenomenology required.
Singular terms and objectivity from social structure: even reference and the objectivity of claims (the gap between “what we take to be correct” and “what is correct”) are recovered from the structure of perspectival scorekeeping rather than imported as primitives.
Anti-representationalist but not anti-realist: inferentialism is compatible with robust truth, reference, and a mind-independent world — it just refuses to take those as semantic ground floor.

Connections

Conceptual Contribution

Claim: A complete theory of linguistic meaning can — and should — be built from the publicly observable practice of giving and asking for reasons, with no mental states (beliefs, intentions) in the foundations. Reference and truth are downstream of inferential articulation, not upstream of it.
Mechanism: Deontic scorekeeping: every participant in discourse maintains a score on every other participant tracking which commitments they have undertaken, which entitlements they hold, and which incompatibilities are in play. The content of a sentence is exhaustively given by its inferential articulation in this scorekeeping practice — what entitles you to assert it, what asserting it entitles you to, and what asserting it is incompatible with. Logical vocabulary is a downstream expressive layer that lets implicit inferential commitments be made explicit as further claims.
Concepts introduced/used: Inferentialism, Material Inference, Deontic Scorekeeping, Discursive Practice, Commitment (Brandom), Entitlement (Brandom), Incompatibility (Brandom), Sapience vs Sentience, Expressive Role of Logic, Semantics-Without-Minds.
Stance: foundational philosophical monograph / lecture series.
Relates to: The direct philosophical underwriting of the public-semantics / commitment-based line in agent communication: Brandom shows you can have a full theory of meaning — not just a thin behavioural sketch — without invoking mental states, which is precisely what Singh needs and what Cohen and Levesque’s mentalistic ACL semantics could not deliver. CBCL and the commitment-machine tradition can be read as engineering realisations of deontic scorekeeping at wire-format granularity: a CBCL trace is a deontic score, and a dialect contract names which inferential moves are licensed. Genealogically the book is the late chapter of the Wittgenstein / Sellars / Quine line; the Myth of the Given (Sellars) is the move that lets meaning bypass preconceptual reference, and Brandom shows how far that move actually carries.

An Ontology for Commitments in Multiagent Systems - Singh

An Ontology for Commitments in Multiagent Systems: Toward a Unification of Normative Concepts

Reference: Singh, M. P. (1999). An Ontology for Commitments in Multiagent Systems: Toward a Unification of Normative Concepts. Artificial Intelligence and Law 7(1): 97–113. Kluwer. DOI · Author copy via Academia.edu · Singh publications (NCSU)

Summary

This paper is the formal core of Singh’s commitment-based programme — a piece that sits between the polemical Rethinking the Principles (1998) and the operationalised commitment machines line (Yolum & Singh 2002). Singh argues that the multiplicity of normative concepts used across MAS, deontic logic, and law — obligation, permission, prohibition, promise, contract, delegation, cancellation, release — can be unified by taking the social commitment as the basic ontological primitive and reconstructing the rest as patterns over commitments. A social commitment is a four-place relation: a debtor is committed to a creditor for the fulfilment of some condition in the context of a particular institution or social scope. Once these four roles are fixed, the standard normative operations — create, discharge, cancel, release, delegate, assign — become commitment-state transitions, and the deontic vocabulary becomes a derived layer over the commitment substrate.

The construction is deliberately public: commitments live in the social state, not in the heads of any agent. A commitment exists when a publicly observable act has created it (a promise speech act, a contract signing, an assertion under appropriate sincerity context); it persists until a publicly observable act has discharged or cancelled it. The truth-conditions for “agent A is committed” are externally checkable: they reference the social record, not A’s mental state. This is the exact alternative to the mentalistic semantics of FIPA / Cohen and Levesque 1995 that Rethinking the Principles called for. The paper also sets up the bridge to law: Singh notes the close fit with Jones and Sergot’s “count-as” relation, with deontic logic, and with the speaks-for tradition in distributed systems — establishing commitments as a unifying normative substrate across philosophy, law, MAS, and computer security.

For CBCL and the broader public-semantics line, this is the ontology document: it defines what “commitment” means precisely enough that protocol designers can map performatives onto commitment-state transitions and verifiers can monitor compliance from a transcript. The four-place structure (debtor, creditor, condition, context) maps almost directly onto the ledger-of-commitments architecture in Fornara & Colombetti 2004 and the dialect contracts in CBCL. The paper is also the place to cite when arguing that commitment-based ACL semantics is not merely a behavioural surrogate but a real normative theory with established connections to legal and deontic logic.

Key Ideas

Commitment as the primitive normative concept: a four-place relation C(debtor, creditor, condition, context) — agent x is committed to agent y for the fulfilment of condition q in the social context s. The four roles must always be specified; commitments without a creditor are degenerate.
Standard commitment operations: create (a new commitment comes into being via a public act), discharge (the condition is satisfied), cancel (the debtor unilaterally retracts, possibly incurring meta-commitment), release (the creditor waives), delegate (the debtor passes the obligation to a third party with creditor consent), assign (the creditor passes the entitlement).
Conditional commitments: CC(x, y, p ⊃ q, s) — x is committed to y to bring about q if p holds. The conditional structure handles contracts, contingent obligations, and protocol-state dependencies.
Discharge by satisfaction: a commitment is discharged when its condition is satisfied (in the relevant social interpretation); discharge is monotone — once discharged, the commitment is closed.
Deontic vocabulary as derived: obligation, permission, prohibition, right, and duty are reconstructable from commitment patterns plus the relevant institutional context.
Public, externally checkable semantics: commitments are facts about the social record, not about agent mental states. Verification is by inspection of the transcript and the institutional rules.
Bridges to legal informatics and deontic logic: the framework is explicitly compatible with Jones and Sergot’s count-as relation and with classical deontic-logic operators, positioning commitments as the unifier across philosophy, law, MAS, and distributed-security normative reasoning.

Connections

Conceptual Contribution

Claim: The proliferation of normative concepts across MAS, deontic logic, and law can be unified by taking the social commitment — a four-place relation C(debtor, creditor, condition, context) — as the basic primitive and reconstructing obligation, permission, prohibition, contract, and delegation as commitment patterns. Commitments are public: their existence is determined by observable acts and observable conditions, not by agent mental states.
Mechanism: Define commitments as four-place relations (debtor / creditor / condition / context) and conditional commitments analogously. Specify the operations create / discharge / cancel / release / delegate / assign as commitment-state transitions. Show how standard deontic-logic operators and standard legal concepts (promise, contract, breach, novation) reduce to patterns over these primitives. Sketch the bridge to Jones and Sergot’s count-as analysis of institutional facts.
Concepts introduced/used: Social Commitment, Conditional Commitment, Commitment Operations (create / discharge / cancel / release / delegate / assign), Debtor, Creditor, Condition, Context (Commitment), Deontic Reduction.
Stance: foundational technical paper / unifying ontology.
Relates to: The formal statement of the programme Singh 1998 argued for polemically; the bridge to the operational accounts in Yolum & Singh 2002, Yolum & Singh 2002b, and Fornara & Colombetti 2004. The philosophical complement is Brandom: Singh’s commitments are precisely the commitment leg of Brandom’s deontic scorekeeping triple. The legal complement is Jones & Sergot 1993 — count-as gives the institutional grounding for what makes a publicly observable act count as creating a commitment. The distributed-systems complement is the speaks-for tradition (Lampson et al. 1992) — credentials and delegated assertion authority are commitment patterns of the same family. CBCL’s dialect contracts and verdict ledger directly instantiate this ontology at wire-format granularity.

Commitment-based Semantics

Approach that grounds ACL message meaning in public social commitments rather than private mental states — making conformance verifiable.

In this vault

ACL Rethinking Principles
Agent Communication Languages - Rethinking the Principles
Agent Communication And Institutional Reality
A Common Ontology Of ACLs
Public Semantics
Mentalistic Semantics
Flexible Protocol Specification and Execution
A Commitment-Based Approach to Agent Communication
CBCL - Safe Self-Extending Agent Communication — modern LangSec-grounded ACL inheriting Singh’s social-agency programme; dialect installation as public commitment

Semantics and Conversations for an ACL

Semantics and Conversations for an Agent Communication Language

Reference: Yannis Labrou and Tim Finin (1998). In Readings in Agents (Huhns & Singh eds., Morgan Kaufmann), reprinted from IJCAI-97. Source file: labrou-finin-1998.pdf. URL

Summary

Labrou and Finin supply the missing formal semantics for KQML. They treat KQML performatives as speech acts and, drawing on Searle and Vanderveken, describe each reserved performative (tell, ask-if, advertise, sorry, broker-one, …) by its preconditions, postconditions, and completion conditions over the cognitive states (BEL, KNOW, WANT, INT) of sender and receiver. On top of this performative-level semantics they add a conversation policy layer: a Definite Clause Grammar specifying legal sequences of performatives (conversations), giving KQML a two-tier account of meaning — individual acts plus interaction protocols.

This is the canonical mentalistic semantics that ACL Rethinking Principles critiques: KQML’s meaning is defined by what the agents are supposed to believe, know, and intend before and after sending each message, which is exactly the private, unverifiable mental-state grounding Singh objects to.

Key Ideas

KQML performatives carry illocutionary force; their meaning is given by speech-act-style preconditions and postconditions over agent mental states.
Four primitive mental-state operators: BEL(A,X), KNOW(A,X), WANT(A,X), INT(A,X); conjunctions and negations permitted but disjunction forbidden inside BEL/KNOW/WANT/INT.
Each performative specifies: intuitive meaning, content description, Pre(A)/Pre(B) preconditions, Post(A)/Post(B) postconditions, Completion condition, and an expected response performative.
advertise is analysed as a commissive — the sender commits to being able to process a later performative of the advertised type; tell as assertive; ask-if as directive.
Conversation policies: legal message sequences expressed as a DCG so that agents can plan and recognise multi-step exchanges (register-then-advertise-then-ask, broker patterns, etc.).
Negation of a mental-state expression means “not provable” from the agent’s knowledge base — making the semantics relative to the particular agent’s reasoner.

Connections

Conceptual Contribution

Claim: An Agent Communication Language acquires meaning at two layers — (1) per-performative speech-act semantics expressed as pre/post-conditions over the sender’s and receiver’s beliefs, knowledge, wants, and intentions, and (2) conversation policies expressed as a formal grammar over sequences of performatives — and this combination suffices to specify KQML.
Mechanism: Adopts Austin/Searle/Vanderveken speech-act categories, introduces the BEL/KNOW/WANT/INT operators, writes out pre/post/completion schemas for five reserved performatives (advertise, ask-if, tell, sorry, broker-one), and layers a Definite Clause Grammar to compose them into conversations.
Concepts introduced/used: Mentalistic Semantics, Performatives, Illocutionary Force, Conversation Policies, Preconditions and Postconditions, Commissives
Stance: constructive / foundational
Relates to: Direct target of the ACL Rethinking Principles critique — Singh names this mental-state grounding as the reason KQML compliance cannot be verified. Supplies the machinery later reused by FIPA-ACL and problematised by Verifiable Semantics for ACLs and Commitment-based Semantics.

Tags

Agent Communication Languages - Rethinking the Principles

Agent Communication Languages: Rethinking the Principles

Reference: Singh, M. P. (1998). IEEE Computer (December 1998). Source file: singh-acl.pdf. URL

Summary

Singh argues that mainstream ACLs like KQML and FIPA/Arcol are built on an untenable mentalistic semantics — grounding message meaning in the sender’s beliefs and intentions — which cannot be verified from the outside and therefore cannot serve as a compliance standard. For true interoperability in heterogeneous multi-agent systems, he proposes shifting to a social agency model in which ACL semantics is defined in terms of public commitments, roles, and conventions rather than private mental states.

The paper maps the design space of ACLs along phisssspective (private/public), type of meaning (personal/conventional), basis (semantic/pragmatic), context (fixed/flexible), coverage (of communicative acts), and construction autonomy (design/execution). It motivates “societies” of agents with published protocols, where compliance becomes testable and dialects can usefully coexist. The move from mental to social semantics underpins later work on commitment-based protocols.

Key Ideas

Mentalistic ACL semantics is non-verifiables => poor basis for standards.
Social agency: commitments, roles, conventions as public meaning.
Design/execution autonomy orthogonal and both important.
Dialects are OK; idiolects are not.
Protocols as flexible specifications, not fixed FSMs.

Connections

Agent Communication Languages
FIPA-ACL
FIPA-ACL Specifications
KQML
Speech Act Theory
Commitment-based Semantics
Mentalistic Semantics
Public Semantics
Verifiable Semantics
Interaction Protocols
Conversation Policy
Multi-Agent Systems
Communicative Actions for Artificial Agents - Cohen Levesque — the mentalistic high-water mark this paper critiques
An Ontology for Commitments in Multiagent Systems - Singh — Singh’s own formal sequel: four-place commitment ontology
Articulating Reasons - Brandom — philosophical underwriting of Public Semantics
Making It Explicit - Brandom
Jones-Sergot Normative Systems — Counts-As Relation / institutional grounding
CBCL - Safe Self-Extending Agent Communication — O’Connor 2026 contemporary realisation

Conceptual Contribution

Claim: Mentalistic ACL semantics (KQML, FIPA/ARCOL) cannot ground interoperability because compliance with sincerity and belief conditions is externally unverifiable; ACLs should be rebuilt on a social semantics of public commitments, roles and conventions.
Mechanism: Singh maps the ACL design space along six axes — perspective (private/public), meaning type (personal/conventional), basis (semantic/pragmatic), context (fixed/flexible), coverage (communicative-act repertoire), and construction autonomy (design-time vs. run-time). He uses this scheme to argue that FIPA/KQML occupy an untenable region, and sketches a social-agency alternative in which agents belong to “societies” with published protocols, commitments are first-class, and dialects (but not idiolects) are tolerated.
Concepts introduced/used: Social Agency, Commitment-Based Semantics, Mentalistic Semantics, Conversation Policy, Dialect vs Idiolect, Design Autonomy, Execution Autonomy, ACL Verifiability
Stance: critique
Relates to: Directly targets the mentalistic stance of Agent-Oriented Programming, KQML as an Agent Communication Language, and FIPA-ACL; its social-semantic programme is operationalised by An Interaction-oriented Agent Framework for Open Environments (commitment-based Mercurio/JaCaMo) and cited approvingly by the surveys The State of the Art in Agent Communication Languages and Trends in Agent Communication Language.

Tags

Agent Communication Languages

A concept hub for agent communication languages (ACLs): languages whose speech acts let software agents exchange beliefs, goals, and commitments.

Canonical Languages

KQML — original knowledge-query language
FIPA-ACL — standardised successor

Surveys & Principles

The State of the Art in Agent Communication Languages
Trends in Agent Communication Language
ACL Rethinking Principles — Singh, mental vs. social semantics
Agent Communication Languages - Rethinking the Principles
A Common Ontology Of ACLs
Toward Automated Evolution of ACLs
Towards Automating the Evolution of Linguistic Competence

Semantics

Conversations & Protocols

Domain instances

Common Business Communication Language — McCarthy 1975/1982
CBCL - Safe Self-Extending Agent Communication — O’Connor 2026 (LangSec ’26): contemporary Lean-verified DCFL-bounded ACL realising McCarthy’s CBCL vision

Trends in Agent Communication Language

Reference: Chaib-draa, B., Dignum, F. (2002). Computational Intelligence, Vol. 18, No. 2. Source file: trends-in-acl.pdf. URL

Summary

Editorial introduction to a special issue on ACLs that surveys the field’s major research threads. The authors review the origins of ACLs (KSE, KQML/KIF, FIPA-ACL based on ARCOL), situating them as intentional/social layers above transport protocols (TCP/IP, HTTP, IIOP). They highlight five core issues: theories of agency underpinning the semantics, ACL semantics proper (pre-/post-/completion conditions vs. rational effects), verification of compliance and protocols, treatment of ontologies, and completeness of message-type sets.

The paper emphasizes tensions between mentalistic semantics (inherited from Searle/Cohen-Levesque speech-act theory) and social alternatives (Singh), and argues conversation policies/protocols are a primary practical vehicle for tractable agent interaction. It closes by reviewing ad-hoc treatment of ontologies and the limits of KQML and FIPA-ACL message-type coverage (e.g., missing commissives in FIPA-ACL).

Key Ideas

ACLs operate at intentional/social layer above transport.
Mentalistic (FIPA) vs. social (Singh) semantics tension.
Verifiability of sincerity/semantics is largely infeasible.
Conversation policies make ACL use tractable.
Ontology integration remains largely ad-hoc.

Connections

Conceptual Contribution

Claim: ACL research clusters around five persistent issues — theory of agency, ACL semantics, verification, ontologies, and completeness of message-type repertoires — and progress requires reconciling mentalistic and social semantics via practical conversation policies.
Mechanism: Chaib-draa and Dignum trace ACLs from the KSE through KQML/KIF to FIPA-ACL/ARCOL, situating them as an intentional/social layer above TCP/HTTP/IIOP transports, and survey each issue. They highlight Cohen–Levesque rational-effect semantics vs. Singh’s social commitments, argue sincerity verification is generally infeasible, note FIPA-ACL’s missing commissives, and promote conversation policies as the practical tractability lever.
Concepts introduced/used: ACL Layering, Rational Effect, Conversation Policy, Protocol Verification, Commissives, Theory of Agency, Ontology Grounding
Stance: survey
Relates to: A companion to The State of the Art in Agent Communication Languages; summarises the tension sharpened in Agent Communication Languages - Rethinking the Principles and motivates the commitment-based turn realised in An Interaction-oriented Agent Framework for Open Environments; its ontology concern links to Ontology Change Classification and Survey.

Tags

The State of the Art in Agent Communication Languages

Reference: Kone, Shimazu, Nakajima (2000). Knowledge and Information Systems, Springer. Source file: The_State_of_the_Art_in_Agent_Communication_Langua.pdf. URL

Summary

A critical review of ACL design circa 2000. The authors lay out a generalized ACL framework structured around eight principles (heterogeneity, cooperation/coordination, separation, interoperability, transparency, extensibility/scalability, performance, and security). They distill ACL specifications into four components: message format, semantic model, interaction protocols, and shared ontologies/content language.

The paper surveys major ACLs — KQML with KIF and facilitator mediation, France Telecom’s ARCOL with its rational-action semantics, the FIPA standard derived from ARCOL, OAA’s ICL, and mobile-agent LOGOS — documenting each approach’s advantages and limitations (lack of formal semantics, low heterogeneity, missing shared ontologies, weak negotiation protocols). It closes by identifying open issues and pointing to the social-agency approach of Singh as a promising direction.

Key Ideas

Eight ACL design principles as evaluation yardstick.
Four-part ACL spec: format, semantics, protocols, ontology.
KQML vs. ARCOL/FIPA as declarative approaches; OAA/LOGOS as procedural.
Speech-act-derived communicative act categories.
Key open issues: formal semantics, heterogeneity, shared ontologies.

Connections

Conceptual Contribution

Claim: An ACL should be evaluated against eight design principles and factored into four orthogonal components, revealing systematic gaps (formal semantics, heterogeneity, shared ontologies, negotiation) in the ACLs available at the turn of the millennium.
Mechanism: Kone, Shimazu and Nakajima enumerate eight principles (heterogeneity, cooperation/coordination, separation, interoperability, transparency, extensibility/scalability, performance, security) and a four-part ACL template (message format, semantic model, interaction protocols, shared ontology/content language). They apply this lens to KQML+KIF, ARCOL, FIPA-ACL, OAA’s ICL and LOGOS, and close by endorsing Singh’s social-agency direction.
Concepts introduced/used: ACL Design Principles, KQML, KIF, ARCOL, FIPA-ACL, OAA ICL, LOGOS, Rational Action Semantics, Facilitator, Content Language
Stance: survey
Relates to: Sits alongside Trends in Agent Communication Language as a companion turn-of-2000s assessment; its endorsement of social semantics anticipates Agent Communication Languages - Rethinking the Principles and is realised by An Interaction-oriented Agent Framework for Open Environments; references ontology issues surveyed in Ontology Change Classification and Survey.

Tags

KQML as an Agent Communication Language

Reference: Tim Finin, Richard Fritzson, Don McKay, and Robin McEntire (1994). CIKM ’94 (Proceedings of the Third International Conference on Information and Knowledge Management). Source file: 191246.191322.pdf. URL

Summary

Foundational paper on the Knowledge Query and Manipulation Language (KQML), developed under the ARPA Knowledge Sharing Effort. KQML is both a message format and a message-handling protocol for run-time knowledge sharing among intelligent agents. It builds on speech-act theory: each message (a performative) carries an illocutionary force (ask, tell, subscribe, advertise, recommend, broker, recruit, etc.) atop a content language (often KIF) and an ontology reference.

The paper describes the three-layer structure (content / message / communication), facilitator agents that provide matchmaking, brokering and content-based routing, and implementations including routers, facilitators, and KRIL interface libraries. KQML became the reference point against which later ACLs (notably FIPA-ACL) were designed.

Key Ideas

Performatives as speech-act-inspired message types
Separation of content language, message layer, and transport
Facilitators for advertise/subscribe, brokering, recruitment, routing
Reserved performatives: ask-if/ask-all, tell, stream-all, subscribe, monitor, advertise, recruit
KIF + ontologies as the assumed content layer

Connections

Conceptual Contribution

Claim: Interoperable knowledge sharing among heterogeneous intelligent agents requires a three-layer communication language (content / message / communication) whose message layer is built from speech-act-inspired performatives, and whose runtime infrastructure provides facilitator agents for matchmaking and brokering.
Mechanism: Specify ~30 reserved performatives (ask-if, tell, subscribe, advertise, recruit, broker-one, …) that wrap a content expression (typically KIF) with an ontology reference and transport metadata; implement via routers, facilitators, and per-application KRIL interface libraries; demonstrate advertise/subscribe, content-based routing, and recruitment patterns.
Concepts introduced/used: KQML, Performatives, Speech Act Theory, Facilitators, Facilitator Agents, Mentalistic Semantics, KIF, Ontologies, Agent Communication Languages, Conversation Policy, Interaction Protocols
Stance: engineering / standard-proposal
Relates to: Foundational reference against which FIPA-ACL, A Common Ontology Of ACLs, ACL Rethinking Principles, and Agent Communication Languages - Rethinking the Principles argue (over mentalistic vs commitment-based semantics). Performatives-as-protocol anticipates Agora’s Protocol Documents in A Scalable Communication Protocol for Networks of LLMs and the MCP/A2A/ANP layer of modern LLM agents (Model Context Protocol, Agent-to-Agent Protocol, Agent Network Protocol).

Tags

KQML Overview

An Overview of KQML: A Knowledge Query and Manipulation Language

Reference: KQML Advisory Group — Tim Finin, Don McKay, Rich Fritzson (and Hans Chalupsky, Stuart Shapiro, Gio Wiederhold) (1992/1993). Technical report, DARPA Knowledge Sharing Effort. Source file: kqmloverview.pdf. URL

Summary

This foundational technical report introduces KQML, the language and protocol designed under the DARPA-sponsored Knowledge Sharing Effort to enable interoperability among heterogeneous intelligent agents and knowledge-based systems. It identifies the canonical module types — End User Applications (EUAs), Knowledge-Based Systems (KBs), Knowledge Base Repositories (KBRs), Databases (DBs), and Active Sensors (ASs) — and enumerates the fifteen possible interfaces between them, selecting KB-to-KB knowledge interchange as the central target.

KQML is organized as three layers: a content layer (domain content in KIF or other logic), a message layer (performatives like tell, ask-one, subscribe, advertise, register), and a communication layer (sender, receiver, reply-ids, transport). The report details performatives, facilitators/routers (SKTP), ontology/topic matching, and a Prolog-based implementation. It set the vocabulary and architectural template for nearly all subsequent agent-communication work.

Key Ideas

Three-layer design: content, message, communication.
Performatives as named speech-act-like primitives (tell, ask, subscribe, advertise).
Facilitators/mediators (SKTP) for routing and knowledge-based-service discovery.
Module taxonomy: EUA, KB, KBR, DB, AS.
Separation of content language (KIF) from communication language (KQML).

Connections

KQML
FIPA-ACL
Agent Communication Languages
Ontologies
Speech Act Theory
Performatives
Facilitators
KQML Language And Protocol — journal companion
KQML as an Agent Communication Language — tutorial companion
KQML - A Language And Protocol For Knowledge And Information Exchange — 1994 workshop original
KIF
Mentalistic Semantics
Conceptualization

Conceptual Contribution

Claim: Large heterogeneous knowledge-based systems need a standard high-level language and protocol for interchange that separates domain content (ontologies/KIF) from communicative intent (performatives) and from transport — KQML provides this missing middle layer.
Mechanism: Defines module taxonomy (EUA, KB, KBR, DB, AS) and their 15 interfaces; proposes KQML’s three-layer architecture (content / message / communication); specifies performatives (tell, ask-one/all, stream, subscribe, advertise, register, broker, recruit, recommend) inspired by speech acts; specifies SKTP (facilitator) protocol for routing, ontology matching, and service discovery; gives a Prolog reference implementation.
Concepts introduced/used: KQML, Performatives, Facilitator, SKTP, Content Language, KIF, Knowledge Sharing Effort, Ontology Matching, Speech Acts
Stance: engineering / foundational
Relates to: The language critiqued in ACL Rethinking Principles and Verifiable Semantics for ACLs for its mentalistic informal semantics; its performatives are inherited by FIPA-ACL and the conversation work in Coordinating Agents Using ACL Conversations; its ontology-sharing aspirations are addressed by Ontolingua Portable Ontology Specifications.

Tags

KQML

Knowledge Query and Manipulation Language — one of the first ACLs, developed in the early 1990s by the ARPA Knowledge Sharing Effort. Performative-based, separating content language from communication.

Primary sources

Agent Communication Languages
FIPA-ACL — the standardised successor
Speech Act Theory
Ontolingua Portable Ontology Specifications — companion Knowledge Sharing Effort project
A Common Ontology Of ACLs
Verifiable Semantics for ACLs
CBCL - Safe Self-Extending Agent Communication — modern DCFL-bounded ACL with the same performative/extensibility ambitions but formal safety guarantees

A Taxonomy of Illocutionary Acts

Reference: Searle, J. R. (1975). In K. Gunderson (Ed.), Language, Mind, and Knowledge (Minnesota Studies in the Philosophy of Science, vol. 7), pp. 344–369. University of Minnesota Press. Reprinted in Expression and Meaning (1979), CUP. Source file: searle_taxonomy_illocutionary_acts.pdf. URL

Summary

Searle develops a principled classification of illocutionary acts, replacing Austin’s intuitive five-category scheme (verdictive, expositive, exercitive, behabitive, commissive) with a taxonomy grounded in twelve significant dimensions of variation — chief among them illocutionary point, direction of fit (words-to-world, world-to-words, double, or null), and expressed psychological state (sincerity condition). Applying these criteria yields five basic classes: Representatives (assertions, conclusions — word-to-world fit, expressing belief), Directives (requests, commands — world-to-word fit, expressing want), Commissives (promises, threats — world-to-word fit, expressing intention), Expressives (thanks, apologies — null direction of fit, expressing various psychological states), and Declaratives (christenings, firings — double direction of fit, typically requiring an extra-linguistic institution).

Searle criticises Austin’s taxonomy for confusing illocutionary verbs with illocutionary acts (verbs are language-relative; acts are not), for overlap among categories, and for lacking a consistent principle of classification. The taxonomy became the standard reference for speech-act theory and, via agent communication language design, provided the fundamental performative vocabulary (tell, ask, promise, declare) inherited by KQML, FIPA-ACL, and later protocol work.

Key Ideas

Twelve dimensions of illocutionary variation; three central ones dominate.
Illocutionary point, direction of fit, expressed psychological state.
Five classes: Representatives, Directives, Commissives, Expressives, Declaratives.
Distinction between illocutionary verbs and illocutionary acts.
Declaratives depend on extra-linguistic institutions.
Critique of Austin: no single principle, verb/act conflation, overlap.
Sincerity conditions as essential to each class.

Connections

Conceptual Contribution

Claim: Illocutionary acts partition into exactly five basic classes (Representatives, Directives, Commissives, Expressives, Declaratives), determined by a small set of semantic dimensions (point, direction of fit, sincerity condition) rather than by surface verbs.
Mechanism: Enumerate twelve dimensions of variation; elevate three (illocutionary point, direction of fit, psychological state expressed) as primary axes; derive the five classes as equivalence classes under these axes; show Austin’s categories conflate verbs with acts and cross-cut the principled axes, producing overlap and miscategorisation (e.g., describe straddles representative/verdictive).
Concepts introduced/used: Illocutionary Point, Direction Of Fit, Sincerity Condition, Representatives, Directives, Commissives, Expressives, Declaratives
Stance: theoretical taxonomy
Relates to: Provides the performative vocabulary taken up by KQML, KQML as an Agent Communication Language, and downstream work on Agent Communication Languages; formalised further in Foundations Of Illocutionary Logic; offers the linguistic underpinning critiqued/extended by Agent Communication Languages - Rethinking the Principles and operationalised in Elephant 2000 - A Programming Language Based on Speech Acts.

Tags

Speech Act Theory

Philosophy-of-language framework (Austin, Searle, Vanderveken) in which utterances perform actions (illocutionary acts) — the semantic backbone of most Agent Communication Languages.

Sources

Foundations Of Illocutionary Logic — Searle & Vanderveken
Three Models for the Description of Language — Chomsky, foundations
Agent Communication And Institutional Reality

Applied in

Lineage

graph TD
  A["Austin (1962)<br/>How to Do Things with Words"] --> A1[Locutionary]
  A --> A2[Illocutionary]
  A --> A3[Perlocutionary]
  A2 --> S["Searle (1969, 1975)<br/>Speech Acts · Taxonomy of Illocutionary Acts"]
  S --> S1[Assertives]
  S --> S2[Directives]
  S --> S3[Commissives]
  S --> S4[Expressives]
  S --> S5[Declarations]
  G["Grice (1975)<br/>Logic and Conversation"] -.cooperative principle.-> S
  S --> V["Searle & Vanderveken (1985)<br/>Foundations of Illocutionary Logic"]
  V --> M["McCarthy (1989)<br/>Elephant 2000"]
  V --> KQML[KQML performatives]
  V --> FIPA[FIPA-ACL performatives]
  M --> FIPA
  KQML --> ACL[[Agent Communication Languages]]
  FIPA --> ACL

Papers: How to Do Things with Words · Speech Acts - An Essay in the Philosophy of Language · A Taxonomy of Illocutionary Acts · Logic and Conversation · Foundations Of Illocutionary Logic · Elephant 2000 - A Programming Language Based on Speech Acts

Belief-Desire-Intention

Alternative spelling of the BDI agent architecture; see BDI for the canonical entry.

In this vault

Rational Action Semantics

Cohen-Levesque-style ACL semantics in which each speech act has a rational effect deducible from the sender’s beliefs and goals — formal but famously unverifiable.

In this vault

Cohen and Levesque

Philip R. Cohen and Hector J. Levesque, whose joint and individual work in the 1980s–1990s formalised intention, joint intention, and the rational-balance constraints on BDI-style agents. Their 1990 paper Intention Is Choice with Commitment (AIJ 42) is the canonical formal model of intention as a persistent goal — a commitment to maintain a goal until it is believed achieved, believed unachievable, or its motivating reason dissolves. Cohen & Levesque (1991) Teamwork extends the analysis to joint action and joint intentions in multi-agent settings.

In this vault

Intention Is Choice with Commitment

Reference: Cohen, P.R. & Levesque, H.J. (1990). Artificial Intelligence 42(3): 213–261. Source file: cohen-levesque-intention-is-choice-with-commitment.pdf. URL

Summary

Cohen and Levesque formalise the “rational balance” that holds between an autonomous agent’s beliefs, goals, actions, and intentions. They define intention as a composite mental attitude: a persistent goal that the agent is committed to pursuing until it is achieved, known to be impossible, or no longer relevant. This yields a modal logic whose axioms capture Bratman’s three functional roles for intention — posing problems for means-end reasoning, acting as a screen of admissibility for future intentions, and prompting the agent to track (and re-try) the success of its actions.

The paper opens with the now-classic “Willie the robot” vignette (uncommitted, overcommitted, then homicidally committed), framing intention as what an agent must reason about to be both reliable and responsive. By relativising intentions to beliefs about another agent’s intentions the authors also sketch a theory of interpersonal commitment that anticipates speech-act and multi-agent communication semantics.

Key Ideas

Persistent goal (P-GOAL): a goal an agent will not drop until it is believed achieved, believed impossible, or its relevance condition fails.
Intention defined as a P-GOAL to have done an action while believing one is about to do it — closing Bratman’s gap between intending and acting intentionally.
Avoids the “side-effect problem”: agents don’t intend foreseen side-effects of their actions.
Mutual/relativised intentions as a foundation for interpersonal commitments and speech acts.
Desiderata list (beliefs, feasibility, non-futility, tracking) becomes a standard benchmark for intention logics.

Connections

Agent-Oriented Programming
Belief-Desire-Intention
BDI Logic
BDI Architecture
Joint Intentions
Commitment
Mental State
Rational Action Semantics
Speech Act Theory
Intentional Stance
Flexible Protocol Specification and Execution
A Commitment-Based Approach to Agent Communication
Communicative Actions for Artificial Agents - Cohen Levesque — the 1995 ICMAS sequel that turns the 1990 framework into an explicit speech-act / ACL semantics; direct ancestor of FIPA-ACL.
FIPA-ACL Specifications
Mentalistic Semantics
ACL Rethinking Principles — Singh’s critique of the BDI-based ACL semantics built on this foundation.

Conceptual Contribution

Claim: Intention is not a primitive mental state but a choice with commitment — a goal plus a meta-policy for when to drop it.
Mechanism: Modal logic over beliefs and goals plus a temporal operator for persistence; intention defined compositionally so its functional roles (planning, filtering, tracking) are theorems rather than axioms.
Concepts introduced/used: Persistent Goal, Commitment, Rational Balance, Mental State, Nested Beliefs, Joint Intentions.
Stance: foundational/formal.
Relates to: Shoham’s Agent-Oriented Programming cites this paper as the prime candidate for grounding AOP’s mental-state semantics; Shoham deliberately chooses a simpler obligation/commitment primitive for AGENT-0 but frames C&L as the rigorous theory AOP languages should eventually implement. The paper also underwrites FIPA-style Mentalistic Semantics and Rational Action Semantics for ACLs.

Tags

FIPA-ACL

The Foundation for Intelligent Physical Agents Agent Communication Language — a standardised successor to KQML, defining performatives with mentalistic semantics (beliefs/intentions of sender and receiver).

Primary source

FIPA-ACL Specifications — the canonical standards documents (FIPA00037 Communicative Act Library, FIPA00061 Message Structure)
Communicative Actions for Artificial Agents - Cohen Levesque — Cohen & Levesque 1995, the direct semantic ancestor

Discussed in

Agent Communication Languages
Speech Act Theory
Multi-Agent Systems
Mentalistic Semantics
Public Semantics
Commitment-based Semantics
An Ontology for Commitments in Multiagent Systems - Singh
CBCL - Safe Self-Extending Agent Communication — DCFL-bounded ACL with public-commitment semantics, addressing the unverifiability of FIPA-ACL’s mentalistic SL semantics