Agent Communications Vault

A curated, wikilink-connected reading vault on agent communication languages, multi-agent systems, capability security, distributed systems, and LLM agents — from McCarthy and Minsky through KQML/FIPA to modern LLM agent protocols.

Each note summarises a paper in its own words (summary, key ideas, conceptual contribution, connections) and is cross-linked to related concepts and papers, forming a navigable graph of the field.

Start with concept-map for a guided tour, or browse the map of content below.

How to contribute

The vault is a plain-text zetl wikilink graph — every note is a markdown file with [[wikilinks]]. Contributions welcome:

Clone: git clone https://github.com/anuna-cooperative/agent-comms-wiki.git
Add or edit notes as plain markdown. New paper notes should follow the structure of existing ones (Reference, Summary, Key Ideas, Connections, Conceptual Contribution, Tags).
Run zetl check to validate links, and zetl build to preview the site locally.
Open a pull request at https://github.com/anuna-cooperative/agent-comms-wiki.

See README for detailed conventions.

Map of Content

Concept Hubs

Foundational

Keeping CALM - When Distributed Consistency is Easy — Hellerstein & Alvaro 2019 (CALM Theorem)
Logic and Lattices for Distributed Programming — Conway, Marczak, Alvaro, Hellerstein & Maier 2012 (BloomL; lattice-typed monotonicity)
Relational Transducers for Declarative Networking — Ameloot, Neven & Van den Bussche 2011 (the formal CALM-theorem proof)
A Comprehensive Study of Convergent and Commutative Replicated Data Types — Shapiro, Preguiça, Baquero & Zawirski 2011 (CRDTs canonical reference)
Concurrency Control in Groupware Systems — Ellis & Gibbs 1989 (Operational Transformation; foundational technique behind Google Docs)
Three Models for the Description of Language — Chomsky 1956
A Mathematical Theory of Communication — Shannon 1948 (founding paper of information theory; Channel Capacity, Shannon Entropy)
Classes of Recursively Enumerable Sets and Their Decision Problems — Rice 1953 (Rice’s Theorem; semantic properties of programs are undecidable)
A Robust Layered Control System — Brooks 1986 (Subsumption Architecture; founding behaviour-based paper)
Ascribing Mental Qualities to Machines — McCarthy 1979
Elephant 2000 - A Programming Language Based on Speech Acts — McCarthy 1989 (PL ancestor of ACLs)
Towards a Mathematical Science of Computation — McCarthy 1963
Correctness of a Compiler for Arithmetic Expressions — McCarthy & Painter 1967
First Order Theories of Individual Concepts and Propositions — McCarthy 1979b
Programs with Common Sense — McCarthy 1959 (Advice Taker)
Recursive Functions of Symbolic Expressions and Their Computation by Machine — McCarthy 1960 (Lisp)
Some Philosophical Problems from the Standpoint of Artificial Intelligence — McCarthy & Hayes 1969 (situation calculus, frame problem)
Epistemological Problems of Artificial Intelligence — McCarthy 1977
Circumscription - A Form of Nonmonotonic Reasoning — McCarthy 1980 (AIJ 13)
Circumscription - Applications to Formalizing Common Sense Knowledge — McCarthy 1986 (AIJ 28)
Generality in Artificial Intelligence — McCarthy 1987 (Turing Award lecture)
Modeling Rational Agents within a BDI-Architecture — Rao & Georgeff 1991
AgentSpeak — Rao 1996 (operational BDI language; Jason is the dominant implementation)
Concurrent Constraint Programming — Saraswat 1989/1993 (Ask-Tell over a monotonic constraint store; unifies CLP, concurrent LP, process synchronisation)
Two Faces of Intention — Bratman 1984
Shared Cooperative Activity — Bratman 1992 (Meshing Subplans; three conditions for cooperation)
SharedPlans — Grosz & Kraus 1996 (canonical computational framework for collaborative joint action; Mutual Belief)
We-intentions — Tuomela & Miller 1988 (irreducibility thesis: we-intentions are not reducible to individual I-intentions)
True Believers - The Intentional Strategy and Why It Works — Dennett 1981
A Taxonomy of Illocutionary Acts — Searle 1975
Logic and Conversation — Grice 1975
Attention Is All You Need — Vaswani et al. 2017
The Bitter Lesson — Sutton 2019
Toward Principles for the Design of Ontologies Used for Knowledge Sharing — Gruber 1995
Time Clocks and the Ordering of Events in a Distributed System — Lamport 1978
Impossibility of Distributed Consensus with One Faulty Process — Fischer, Lynch & Paterson 1985 (FLP)
Brewers Conjecture and the Feasibility of Consistent Available Partition-Tolerant Web Services — Gilbert & Lynch 2002 (CAP proof)
Knowledge and Common Knowledge in a Distributed Environment — Halpern & Moses 1990
End-to-End Arguments in System Design — Saltzer, Reed & Clark 1984
A Universal Modular Actor Formalism for Artificial Intelligence — Hewitt, Bishop & Steiger 1973
Communicating Sequential Processes — Hoare 1978
A Calculus of Communicating Systems — Milner 1980 (CCS; algebraic concurrency, Bisimulation)
A Calculus of Mobile Processes — Milner, Parrow & Walker 1992 (the Pi-Calculus; name-passing concurrency)
Mobile Ambients — Cardelli & Gordon 1998 (locations as primary mobile entity; Ambient Calculus)
Linear Logic — Girard 1987 (resource-aware logic; Curry-Howard Correspondence for Session Types)
On the Acceptability of Arguments — Dung 1995 (abstract Argumentation Framework; nonmonotonic-reasoning unifier)
Commitment in Dialogue — Walton & Krabbe 1995 (Dialogue Typology: persuasion / negotiation / deliberation / inquiry / information-seeking / eristic)
Fallacies - Hamblin — Hamblin 1970 (founding text of formal dialectic; Commitment Store)
Convention - Lewis — Lewis 1969 (game-theoretic foundation of convention; Common Knowledge (Convention))
The Strategy of Conflict — Schelling 1960 (Focal Point / Schelling Point coordination; credible commitment)
The Evolution of Cooperation — Axelrod 1984 (Iterated Prisoners Dilemma; Tit-for-Tat; Reciprocity)
Counterspeculation Auctions and Competitive Sealed Tenders — Vickrey 1961 (Vickrey Auction / Second-Price Auction; Mechanism Design foundation)
Algorithm = Logic + Control — Kowalski 1979
Can Programming Be Liberated from the von Neumann Style — Backus 1978 (Turing Award lecture)
The Heart of Spritely - Distributed Objects and Capability Security — Lemmer-Webber, Farmer & Sims 2025 (Goblins / OCapN)
Programming Semantics for Multiprogrammed Computations — Dennis & Van Horn 1966 (original capabilities)
The Confused Deputy - Hardy — Hardy 1988
EROS - A Fast Capability System — Shapiro, Smith & Farber 1999
Capability-based Financial Instruments — Miller, Morningstar & Frantz 2000
Capability Myths Demolished — Miller, Yee & Shapiro 2003
Robust Composition - Towards a Unified Approach to Access Control and Concurrency Control — Miller 2006 (PhD thesis, THE E reference)
Distributed Electronic Rights in JavaScript — Miller, Van Cutsem & Tulloh 2013
Trustworthy Proxies - Virtualizing Objects with Invariants — Van Cutsem & Miller 2013
SPKI-SDSI — Rivest, Lampson, Ellison et al. 1996/1999 (RFC 2693; capability-style PKI; Linked Local Names)
Decentralized Identifiers — W3C 2022 (DIDs + VCs; modern decentralised identity)
Capn Proto — Varda 2013–present (modern CapTP; Three-Party Handoff; capability-secure RPC)
A Framework for Representing Knowledge — Minsky 1974 (Frames)
The Protection of Information in Computer Systems — Saltzer & Schroeder 1975
Distributed Snapshots Determining Global States of Distributed Systems — Chandy & Lamport 1985
Intelligence Without Representation — Brooks 1991
The Extended Mind — Clark & Chalmers 1998
The Part-Time Parliament — Lamport 1998 (Paxos)
In Search of an Understandable Consensus Algorithm — Ongaro & Ousterhout 2014 (Raft; understandability-driven consensus)
Practical Byzantine Fault Tolerance — Castro & Liskov 1999 (PBFT; the practical Byzantine Agreement protocol)
HotStuff — Yin et al. 2019 (linear-and-responsive BFT; Chained Consensus underlying Diem/Aptos)
Generative Communication in Linda — Gelernter 1985 (Linda / tuple spaces; canonical Coordination Language)
KLAIM — De Nicola, Ferrari & Pugliese 1998 (Linda + localities + mobile eval; formal model for mobile agents)
Reo — Arbab 2004 (channel-based coordination; programmable connectors; algebraic counterpoint to Linda)
On Agent-Based Software Engineering — Jennings 2000
The Semantic Web — Berners-Lee, Hendler & Lassila 2001
ReAct Synergizing Reasoning and Acting in Language Models — Yao et al. 2023
Reflexion Language Agents with Verbal Reinforcement Learning — Shinn et al. 2023
The Knowledge Level — Newell 1982
The Society of Mind — Minsky 1986 (MAS wellspring)
How to Do Things with Words — Austin 1962
Speech Acts - An Essay in the Philosophy of Language — Searle 1969
Minds Brains and Science — Searle 1984
Studies in the Way of Words — Grice 1989
Philosophical Investigations - Wittgenstein — Wittgenstein 1953 (meaning as use; language-games; rule-following; private-language argument — grandparent of Inferentialism and Public Semantics)
Two Dogmas of Empiricism - Quine — Quine 1951 (analytic-synthetic collapse; Semantic Holism; web of belief)
Empiricism and the Philosophy of Mind - Sellars — Sellars 1956 (Myth of the Given; Space of Reasons; mentalistic talk as theoretical posit)
Articulating Reasons - Brandom — Brandom 2000 (entry point to Inferentialism; Deontic Scorekeeping; Semantics-Without-Minds)
Making It Explicit - Brandom — Brandom 1994 (the full inferentialist treatise; reference manual)
Assertion - Stalnaker — Stalnaker 1978 (Common Ground / Context Set update semantics; operational counterpart to Grice)
Convention - Lewis — Lewis 1969 (game-theoretic convention; Common Knowledge (Convention))
Languages and Language - Lewis — Lewis 1975 (Convention of Truthfulness and trust; abstract L vs social language)
Jones-Sergot Normative Systems — Jones & Sergot 1993 (Counts-As Relation; constitutive/regulative rules; foundation of normative MAS)
Epistemological Fault Lines Between Human and Artificial Intelligence — Quattrociocchi, Capraro & Perc 2025 (seven fault lines; Epistemia)
What is it to Understand a Directive Speech Act — Dorschel 1989 (citation-only, paywalled)
A Proof Method for Cyclic Programs — Francez & Pnueli 1978 (citation-only, paywalled)
An Application of a Method for Analysis of Cyclic Programs — Francez 1978 (citation-only, paywalled)
Intention Is Choice with Commitment — Cohen & Levesque 1990 (BDI logic)
Communicative Actions for Artificial Agents - Cohen Levesque — Cohen & Levesque 1995 (ICMAS-95; high-water mark of Mentalistic Semantics; direct ancestor of FIPA-ACL)
FIPA-ACL Specifications — FIPA 2002 (FIPA00037 Communicative Act Library; FIPA00061 Message Structure; canonical industry-grade ACL)
An Ontology for Commitments in Multiagent Systems - Singh — Singh 1999 (formal four-place commitment ontology; unifies normative concepts across MAS, law, deontic logic)
Deals Among Rational Agents — Rosenschein & Genesereth 1985
The Synthesis of Digital Machines with Provable Epistemic Properties — Rosenschein & Kaelbling 1986
IPFS Content-Addressed Versioned P2P File System — Benet 2014
Theory of Self-Reproducing Automata — von Neumann
Probabilistic Logics and the Synthesis of Reliable Organisms from Unreliable Components — von Neumann 1952 / 1956 (Caltech lectures, Automata Studies; founds fault-tolerant computing via TMR and multiplexing; ε < 1/6 threshold; direct ancestor of BFT)
Foundations of Logic Programming - Lloyd
Foundations Of Illocutionary Logic — Searle & Vanderveken
Assigning Meanings to Programs — Floyd
An Axiomatic Basis for Computer Programming - Hoare — Hoare 1969 (Hoare Logic; pre/post-conditions; loop invariant; root of contract-based verification)
Algorithmic Information Theory - Grunwald Vitanyi
How Do Committees Invent — Conway
Seven Turrets Of Babel

Causal Inference (CIVeX-adjacent)

Causal Diagrams for Empirical Research - Pearl — Pearl 1995 (DAGs + do-Calculus + Backdoor Criterion; modern graphical causal inference)
Causality - Pearl — Pearl 2000/2009 (Cambridge UP textbook; Structural Causal Model; Ladder of Causation; counterfactuals)
Identification of Joint Interventional Distributions - Shpitser Pearl — Shpitser & Pearl 2006 (AAAI; complete ID Algorithm; do-calculus completeness)
Potential Outcomes Framework - Rubin — Rubin 1974 (Rubin Causal Model; the other half of the causal toolkit; ignorability, ATE)

Cited Foundations (mined from top papers)

Agent Communication Languages (ACLs)

KQML Overview
KQML as an Agent Communication Language
KQML Language And Protocol
ACL Rethinking Principles — Singh
Agent Communication Languages - Rethinking the Principles — Singh (companion)
KQML - A Language And Protocol For Knowledge And Information Exchange — Finin et al. AAAI WS-94
The State of the Art in Agent Communication Languages
Trends in Agent Communication Language
A Common Ontology Of ACLs
Toward Automated Evolution of ACLs
Towards Automating the Evolution of Linguistic Competence
Verifiable Semantics for ACLs
Coordinating Agents Using ACL Conversations
ACRE Agent Conversation Reasoning Engine
Agent Communication And Institutional Reality
Common Business Communication Language
Semantic Description For Agent Design Patterns
Commitment Machines - Yolum and Singh — Yolum & Singh 2002 (ATAL-01; CM→FSM compilation, declarative meaning for protocol states)
Flexible Protocol Specification and Execution — Yolum & Singh 2002 (commitment-based protocols, Event Calculus)
A Commitment-Based Approach to Agent Communication — Fornara & Colombetti 2004 (operational commitment semantics, Precommitment)
CBCL - Safe Self-Extending Agent Communication — O’Connor 2026 (LangSec ’26; Lean 4-verified self-extending ACL constrained to DCFL; realises McCarthy’s Common Business Communication Language)

Multi-Agent Systems and Agent Theory

Intelligent Agents Theory and Practice — Wooldridge
Multiagent Systems Sycara
Agent-Oriented Programming — Shoham
The BOID Architecture — Broersen et al. (deontic BDI)
Multi-Agent Collaboration in AI - Wasif Tunkel
Are Multiagent Systems Resilient to Communication Failures
Ensuring Trustworthy and Ethical Behaviour in Intelligent Logical Agents
An Interaction-oriented Agent Framework for Open Environments
Levels Of Social Orchestration
Structured Communication-Centred Programming for Web Services — Carbone, Honda & Yoshida ESOP 2007 / TOPLAS 2012 (the foundational Choreographic Programming paper)
Multiparty Asynchronous Session Types — Honda, Yoshida & Carbone POPL 2008 (multiparty generalisation; global types → local types projection)
Introduction to Choreographies — Montesi 2023 (Cambridge UP; canonical textbook, citation-only)
Pact - A Choreographic Language for Agentic Ecosystems — Gopinathan et al. 2026 (CP 2026; Choreographic Programming + game theory; LLM-era revival of mentalistic semantics)
On the Monitorability of Session Types — Bartolo Burlò, Francalanza & Scalas 2021 (ECOOP; runtime monitor synthesis for Session Types)

LLM Agents & Modern AI Agents

Agents Framework - Zhou et al
A Scalable Communication Protocol for Networks of LLMs
Survey Of AI Agent Protocols
Survey Of Agent Interoperability Protocols
LLM Agent Communication Protocol Requires Urgent Standardization — Li, Liu & Yuen 2025 (LACP, Narrow Waist Principle)
Why AI Agents Communicate In Human Language
Why Do Multi-Agent LLM Systems Fail
Ripple Effect Protocol
AI Agents Under Threat
MalTool Malicious Tool Attacks
ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems
SoK The Attack Surface of Agentic AI
Open Challenges in Multi-Agent Security — Schroeder de Witt et al. 2025 (definition of Multi-Agent Security as a field; secret collusion, swarm attacks, network-effect threats)
AgentDojo — Debenedetti et al. 2024 (NeurIPS; benchmark for prompt-injection attacks/defences on tool-using agents)
Defeating Prompt Injections by Design — Debenedetti et al. 2025 (CaMeL; control-flow/data-flow separation + capability-gated tools)
Privacy Reasoning in Ambiguous Contexts — Yi et al. 2025 (NeurIPS; Camber disambiguation framework; Contextual Integrity)
Trusted Machine Learning Models Unlock Private Inference — Shumailov et al. 2025 (TCME; capable models as trusted third parties)
Infrastructure for AI Agents — Chan et al. 2025 (TMLR; Agent Infrastructure: attribution, interaction shaping, detection & remediation)
Agents of Chaos
Inter-Agent Trust Models - A Comparative Study
Intent Formalization - A Grand Challenge for Reliable Coding
From Eliza to XiaoIce - Social Chatbots

Agent Economy & Mechanism Design

Virtual Agent Economies — Tomasev et al. 2025 (Sandbox Economy; Mission Economy; auction-based steerable agent markets)
Mechanism Design for Large Language Models — Dütting et al. 2023 (WWW Best Paper; token-level auction over LLM-generated content; monotone aggregation ↔ second-price)
Language Models Can Reduce Asymmetry in Information Markets — Rahaman et al. 2024 (evaluate + forget; resolving the Arrow paradox)
NDAI Agreements — Stephenson et al. 2025 (TEEs + AI as an “ironclad NDA”; solving the Hold-Up Problem)
Do LLM Agents Have Regret — Park et al. 2024 (No-Regret Learning; Regret-Loss training; LLM equilibria in repeated games)
Learning Collusion in Episodic Inventory-Constrained Markets — Friedrich et al. 2024 (AAMAS; deep-RL agents collude in airline-style perishable-good markets)

Emergent Communication & Language Games

Ontologies & Knowledge Representation

Programming Languages & Extensibility

Security & Robust Distributed Systems

A Logic of Authentication — Burrows, Abadi & Needham 1990 (BAN Logic; first widely-adopted protocol-verification method)
Spi Calculus — Abadi & Gordon 1997 (Pi-Calculus + cryptographic primitives; security as process equivalence)
Using Encryption for Authentication — Needham & Schroeder 1978 (Needham-Schroeder Protocol; canonical case-study under the Lowe Attack)
Agent Tcl Flexible Secure Mobile Agents
DAgents Security Book Chapter
Secure Communications Processing for Distributed Languages
A Language-Based Approach To Prevent DDoS
The Halting Problems of Network Stack Insecurity
Proof-Carrying Code - Necula — Necula 1997 (POPL; ship the proof with the code; architectural ancestor of CBCL’s R4 split and CIVeX certificates)
Enforceable Security Policies - Schneider — Schneider 2000 (TISSEC; Execution Monitor enforcement; safety-property characterisation; backdrop for R5 monotone-verdict trace monitor)
Authentication in Distributed Systems - Lampson Abadi Burrows Wobber — Lampson, Abadi, Burrows & Wobber 1992 (TOCS; Speaks-For Calculus; compound principals; foundation for SPKI-SDSI and modern delegated credentials)
PKI Layer Cake - Kaminsky Patterson Sassaman
Security Kernel Lambda Calculus
Agents Secure Interaction in Data Driven Languages
Architectural Patterns for Dependable Software Systems - SOL
Principled Design Of The Modern Web Architecture
Extensible Distributed Coordination
Security Applications Of Formal Language Theory — Sassaman et al. LangSec foundational
Exploit Programming - From Buffer Overflows To Weird Machines — Bratus et al.

Gossip & Peer-to-Peer

Gossiping in Distributed Systems
Gossip-based Aggregation in Large Dynamic Networks
Gossip-Based Computation of Aggregate Information
Myconet Fungi Inspired Superpeer Overlay
Chord — Stoica et al. 2001 (canonical Distributed Hash Table; O(log N) lookup via finger table)
Kademlia — Maymounkov & Mazières 2002 (XOR Metric DHT underlying IPFS / Ethereum / BitTorrent)

Self-* Systems, Adaptation, Trust

Edge, Web, Blockchain

Edge Intelligence Survey
Making Smart Contracts Smarter
Formalise Blockchain Interoperability Patterns
House on Rock - LangSec in Ethereum Classic — Patterson 2017 (ETC Summit talk; Rice’s theorem vs. the gas model)

Backlinks

Linked Pages

House on Rock - LangSec in Ethereum Classic

Reference: Meredith L. Patterson (2017). How to Build a House That Doesn’t Fall Apart (talk). Ethereum Classic Summit, Hong Kong, November 2017. YouTube

Summary

A LangSec critique of Ethereum aimed at the Ethereum Classic community, framed around the parable of the wise and foolish builders and Philip K. Dick’s “reality is that which, when you stop believing in it, doesn’t go away.” Patterson argues Ethereum was built on sand — an ad-hoc, non-executable yellow-paper semantics; a hand-rolled Solidity parser; a test suite with no coverage for delegatecall or invalid opcodes; a design culture that scorned formal methods until hundred-million-dollar losses forced the issue.

The central technical argument is that the gas mechanism does not do what the yellow paper claims it does. Gavin Wood’s stated purpose — “sidestep the inevitable issues stemming from Turing completeness” — confuses a resource bound (a non-semantic, decidable property) with a safety guarantee (a semantic property that Rice’s theorem makes undecidable in general). Gas cannot show a contract “does nothing malicious”; it can only show it eventually halts. Worse, gas creates an adversarial economic game with direct monetary reward for tricking the accounting, and a perverse incentive for honest developers to omit runtime sanity checks because conditionals cost gas.

Patterson’s prescription for Ethereum Classic: standardise on KEVM (an executable operational semantics in the K framework), fix the VM test suite’s gaps, build languages that don’t hide implicit behaviour (method visibility defaults, fallback methods, delegatecall as naked eval), and invest in developer tools — IDEs, live debuggers, verification — that surface what a contract can actually do. “Code is law” requires the meaning of the code to be unambiguous, executable, and visible.

Key Ideas

Rice’s theorem bounds what gas can mean. Non-trivial semantic properties of arbitrary programs are undecidable; resource bounds are non-semantic. Gas therefore cannot sidestep Turing-completeness-induced safety problems, contrary to the yellow paper.
Gas as adversarial game. The accounting is an attack surface, not a safety property; attackers are paid to win. Honest contract authors are weakly pushed toward removing checks to keep gas costs competitive.
LangSec programmer–machine contract. Inputs must have a formal grammar; two implementations of the same spec must accept/reject identical inputs; semantics must be executable so claims about behaviour can be verified mechanically.
Ad-hoc semantics breeds consensus failures. When the yellow paper and cpp-ethereum disagree, cpp-ethereum wins — the denotational semantics is decorative. Discrepancies between clients have already caused real Ethereum consensus failures.
Test suites are part of software design. Official VM tests have no coverage for invalid opcodes or delegatecall — the exact instruction at the heart of the Parity multisig hacks. “VM tests” is false advertising; downstream VM implementations inherit the blind spot.
Case studies of processing-fluency failure.
- DAO: mutual recursion across a defender/attacker code boundary, missed in reviews because reviewers examine functions one at a time (cf. Leveson: accidents emerge from interactions).
- Hacker Gold: =+ typed instead of += — a hand-rolled recursive-descent parser caught nothing; a Bison grammar would have surfaced a shift/reduce conflict.
- Parity multisig (July 2017): fallback method × delegatecall × public-by-default visibility = naked eval on attacker-controlled payload; $31M drained, $150M saved only by counter-theft.
- Parity multisig (Nov 2017): library contract re-initialised by an outsider then suicided, locking $153M in wallets whose code had vanished — “left-pad for multi-million-dollar table stakes.”
KEVM (K framework operational semantics) gives Ethereum an executable semantics; generated interpreter ~20× slower than cpp-ethereum but usable, and supports reachability-based proof of safety/liveness claims.
Cognitive-science constraint. Miller’s 7±2 bounds how much implicit state a programming language can demand before human reasoning fails. Solidity’s implicit defaults (public methods, fallback dispatch, implicit conversions) exceed that budget.
“Worse is better” is unconscionable in a financial system. Sacrificing correctness and completeness to ship first transfers the cost of undefined behaviour onto users.

Connections

Making Smart Contracts Smarter — same semantic gap diagnosis; OYENTE is the symbolic-execution complement to Patterson’s formal-semantics prescription.
Formalise Blockchain Interoperability Patterns — companion move: formalise what was informal.
Security Applications Of Formal Language Theory — the Sassaman/Bratus/Patterson LangSec manifesto this talk operationalises for smart contracts.
The Halting Problems of Network Stack Insecurity — parallel argument that parser/semantics weakness is the root cause of whole vulnerability classes.
Exploit Programming - From Buffer Overflows To Weird Machines — “weird machines” framing applies directly to contracts driven off-spec via delegatecall.
PKI Layer Cake - Kaminsky Patterson Sassaman — Patterson’s earlier demonstration that grammatical discrepancies between implementations are exploitable (SSL CA forgery); same mechanism, different domain.
A Language-Based Approach To Prevent DDoS — language-theoretic remediation as a general pattern.
Operational Semantics, Denotational Semantics, EVM, Solidity, TheDAO, Reentrancy — background concepts.
An Unsolvable Problem of Elementary Number Theory — Church 1936; LangSec’s undecidability heritage behind the Rice’s-theorem argument against gas-as-safety.
Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I — Gödel 1931; the incompleteness ancestor of the semantic-limit arguments.

Conceptual Contribution

Formalise Blockchain Interoperability Patterns

An Approach to Formalise Blockchain Interoperability Patterns

Reference: Guzmán Llambías, Laura González, and Raúl Ruggia (2025). IEEE (preprint, Zenodo). Source file: 13_127.pdf. URL

Summary

Formalises the Temporal Transfer blockchain-interoperability design pattern (instantiated with a gateway/relayer architecture) using Event-B. The authors translate natural-language pattern descriptions into a refined Event-B specification, derive eight safety properties (e.g. token can only be minted on the target chain after being locked on the source), verify them by construction using Rodin, and validate the dynamic behaviour by simulating with ProB.

The contribution is a formal-methods bridge for a family of informally described cross-chain patterns — addressing ambiguity, misinterpretation and lack of guarantees in prior natural-language design-pattern catalogues.

Key Ideas

Event-B refinement captures lock/mint/burn/unlock sequencing across chains
Safety invariants formalise double-spend prevention across ledgers
Rodin discharges proof obligations automatically on invariants/theorems
ProB simulation validates dynamic/functional behaviour of the pattern
Gateway-based Temporal Transfer pattern chosen as instantiation

Connections

Conceptual Contribution

Claim: Blockchain interoperability design patterns — currently specified in ambiguous natural language — can and should be given formal, machine-checkable specifications; Event-B is a suitable vehicle.
Mechanism: Take the Temporal Transfer pattern (gateway-based) and produce an Event-B specification with eight safety properties (lock, mint, transfer, burn, unlock events) refined from abstract to concrete; validate via Rodin/ProB model checker and simulation, discharging Proof Obligations to prove correctness-by-construction.
Concepts introduced/used: Event-B, Refinement, Blockchain Interoperability, Temporal Transfer Pattern, Cross-chain Smart Contracts, Smart Contracts, Formal Verification, Proof Obligations, Model Checking, Design Patterns
Stance: formal / engineering
Relates to: Applies the same formal-specification impulse to cross-chain coordination that Making Smart Contracts Smarter applies to single-chain contract semantics. Shares a methodology with A Modular Approach to Metatheoretic Reasoning for Extensible Languages (refinement, rule-based specs) and a motivation with Agent Communication And Institutional Reality (precise semantics for inter-party protocols).

Tags

Making Smart Contracts Smarter

Reference: Loi Luu, Duc-Hiep Chu, Hrishi Olickel, Prateek Saxena, and Aquinas Hobor (2016). ACM CCS 2016. Source file: 2016-633.pdf. URL

Summary

Investigates security bugs in Ethereum smart contracts arising from a semantic gap between developers’ intuitions and the actual behaviour of the underlying platform. The authors document four classes of vulnerability — transaction-ordering dependence, timestamp dependence, mishandled exceptions, and reentrancy — and formalise a lightweight operational semantics (EtherLite) for EVM execution.

They propose protocol-level remediations (guarded transactions, deterministic timestamps, better exception propagation) and build OYENTE, a symbolic-execution tool that analyses EVM bytecode directly. Running OYENTE on 19,366 live contracts flagged 8,833 as potentially buggy, including TheDAO.

Key Ideas

Semantic gap between Solidity intent and EVM reality causes systemic bugs
Transaction-ordering dependence (TOD): miners reorder within a block
Reentrancy exploited in TheDAO ($60M loss)
Symbolic execution over EVM bytecode as audit tool
“Guarded transactions” proposal: require expected-state precondition

Connections

Conceptual Contribution

Claim: Ethereum smart contracts suffer from a semantic gap between developers’ assumptions and the actual EVM execution model — documenting and fixing this gap at the language-semantics level is critical and tractable.
Mechanism: Identify four concrete bug classes: transaction-ordering dependence (TOD), timestamp dependence, mishandled exceptions (caller must explicitly check return of send), and reentrancy (the DAO vulnerability); formalise a lightweight operational semantics of Ethereum (EtherLite); propose semantic fixes (guarded transactions, deterministic timestamps, exception propagation); build OYENTE, a symbolic-execution tool that scans 19,366 real contracts and flags 8,833 vulnerable.
Concepts introduced/used: Smart Contracts, Transaction-Ordering Dependence, Reentrancy, Operational Semantics, Symbolic Execution, EVM, Semantic Gap, Ethereum, Solidity, TheDAO, Guarded Transactions
Stance: formal-semantic / empirical security
Relates to: Same “formalise ambiguous informal specs” move as Formalise Blockchain Interoperability Patterns. Shares the semantic-gap diagnostic style with PKI Layer Cake - Kaminsky Patterson Sassaman. In the broader vault, complements Agents Secure Interaction in Data Driven Languages and Distributed Security as a case study of formal-method-driven vulnerability discovery.

Tags

Edge Intelligence Survey

Edge Intelligence: Paving the Last Mile of Artificial Intelligence With Edge Computing

Reference: Zhi Zhou, Xu Chen, En Li, Liekang Zeng, Ke Luo, Junshan Zhang (2019). Proceedings of the IEEE, Vol. 107, No. 8, pp. 1738-1762. Source file: Edge_Intelligence_Paving_the_Last_Mile_of_Artificial_Intelligence_With_Edge_Computing.pdf. URL

Summary

A comprehensive survey of Edge Intelligence (EI), the fusion of AI with edge computing that pushes deep-learning training and inference out of centralized cloud datacenters toward the network edge, where the data is generated. The authors motivate EI through the explosion of IoT data, latency/bandwidth limits of cloud AI, and growing privacy concerns. They propose a six-level rating scheme for EI — from cloud-only (Level 0) through various hybrid cloud-edge splits to fully on-device training and inference (Level 6) — and argue the right level is application dependent.

The paper surveys architectures (centralized, decentralized, hybrid distributed training), key performance indicators (training loss, convergence, privacy, communication cost, latency, energy), enabling techniques, and frameworks for DNN training and inference at the edge. It frames EI as a “last mile” extension that unlocks IoT/AR/VR/autonomous applications by co-locating intelligence with data.

Key Ideas

Six-level rating of EI based on amount and path length of data offloading.
Cloud-edge-device synergy reduces latency and energy vs. pure cloud or pure on-device.
Distributed DNN training modes: centralized, decentralized, hybrid.
Privacy-preserving rationale: raw data stays at edge.
EI is a cross-cutting discipline bridging AI, systems, and networking.

Connections

Conceptual Contribution

Claim: AI training and inference should be distributed across a cloud-edge-device hierarchy rather than centralised in the cloud; the optimal split is application-dependent and can be described by a six-level rating.
Mechanism: Systematic survey structured around motivations (latency, privacy, bandwidth, data locality), a six-level EI taxonomy, three distributed-training architectures (centralised, decentralised, hybrid), six KPIs, and enabling techniques (federated learning, gradient compression, DNN splitting, knowledge transfer, gossip training).
Concepts introduced/used: Edge Intelligence, Cloud-Edge-Device Hierarchy, Federated Learning, Gossip Training, DNN Splitting, Gradient Compression, Knowledge Transfer Learning, Six-Level EI Rating
Stance: survey
Relates to: Ties into Edge Intelligence hub and shares gossip-training mechanisms with Gossip-based Aggregation in Large Dynamic Networks and Gossip-Based Computation of Aggregate Information; motivates on-device LLM agents relevant to LLM Agents and A Scalable Communication Protocol for Networks of LLMs.

Tags

Review on Computational Trust and Reputation Models

Reference: Sabater, Sierra (2005). Artificial Intelligence Review. Source file: Review_on_Computational_Trust_and_Reputation_Model.pdf. URL

Summary

A panoramic review of computational trust and reputation models developed for multi-agent systems and electronic commerce. Sabater and Sierra classify models along several dimensions: conceptual basis (cognitive vs. game-theoretical), information sources (direct experience, witness information, sociological signals, prejudice), visibility (global vs. subjective), granularity (single- vs. multi-context), assumptions about cheating behavior, type of exchanged information, and provision of reliability measures.

The survey then applies this framework to representative models (Marsh’s early trust model, Sporas, Histos, ReGreT, AFRAS, FIRE, eBay-style mechanisms, Yu & Singh’s evidential model, etc.), identifying under-explored aspects: sociological information, multi-context reasoning, and principled handling of liars. It argues that as MAS applications grow more complex, trust models must become richer to accommodate social structures and contextual reasoning.

Key Ideas

Trust as cognitive belief vs. game-theoretic subjective probability.
Direct experience, witness (word-of-mouth), sociological signals, prejudice.
Global (online reputation) vs. subjective trust per partner.
Three levels of cheating-resistance: ignored, biasing-only, liars.
Need for multi-context, sociologically-aware trust.

Connections

Conceptual Contribution

Claim: Computational trust/reputation must be classified along several independent dimensions (conceptual basis, information sources, visibility, granularity, cheating assumptions) if models are to be compared and composed rather than merely enumerated.
Mechanism: The authors propose a multi-axis taxonomy and apply it to a dozen canonical models (Marsh, Sporas, Histos, ReGreT, AFRAS, FIRE, eBay-style aggregation, Yu & Singh), using each axis to surface gaps: sociological signals, multi-context trust, and principled liar handling are under-served despite being pivotal for realistic MAS.
Concepts introduced/used: Trust, Reputation, Direct Experience, Witness Reputation, Sociological Reputation, Prejudice, ReGreT, FIRE, Cognitive Trust, Game-Theoretic Trust
Stance: survey
Relates to: Supplies the conceptual vocabulary picked up by self-organisation work such as A Composite Self-organisation Mechanism in an Agent Network (DSmT trust fusion) and contextualises verifiability debates in Agent Communication Languages - Rethinking the Principles; links to Gossip Protocols through witness-information propagation.

Tags

Computational Boundary of a Self

The Computational Boundary of a “Self”: Developmental Bioelectricity Drives Multicellularity and Scale-Free Cognition

Reference: Michael Levin (2019). Frontiers in Psychology, Vol. 10, Article 2688. Source file: fpsyg-10-02688.pdf. URL

Summary

Levin proposes a biologically grounded, scale-free definition of cognitive “Individuals” based on their capacity to pursue goals at a characteristic level of scale and organization. A Self is demarcated by a computational surface — a spatio-temporal “cognitive light cone” defining what events it can measure, model, and influence. Higher goal-directed agency, he argues, evolves smoothly from the primal homeostatic TOTE loop that living things use to reduce stress between current and life-optimal conditions.

The central mechanism is developmental bioelectricity — the ability of cells to form bioelectrical networks (via gap junctions, ion channels) that process information and guide embryogenesis, regeneration, and possibly higher cognition. Levin sketches gradual evolutionary steps from physiological homeostasis in single cells to memory, prediction, and complex cognition, proposing that multi-scale Individuals emerge from the “scale-up of the basic drive of infotaxis.” Implications span cancer biology, AI, bioengineering, and exobiology.

Key Ideas

Individuals defined by goal-pursuit capability and cognitive light cone, not anatomy.
Developmental bioelectricity as substrate for scale-free cognition.
Continuum from stimulus-response to predictive agency (TOTE loops).
Cancer as a shift in the boundary of the Self to a single-cell scope.
Testable predictions for biomedicine, evolutionary biology, and AI.

Connections

Conceptual Contribution

Claim: A cognitive “Individual” is demarcated not by anatomy but by a computational surface — the spatio-temporal cognitive light cone over which it can measure, model, and act — and such Selves scale up smoothly via developmental bioelectricity from single cells to multicellular organisms.
Mechanism: Synthesises cognitive science, evolutionary biology, and developmental physiology; defines Individuality by goal-pursuit capacity at a level of organisation; proposes a continuum of cognitive powers (TOTE loops parametrised by memory/prediction depth); argues gap-junctional bioelectric networks are the substrate that binds sub-agents into larger Selves, with cancer as a concrete boundary-shrinkage phenomenon.
Concepts introduced/used: Cognitive Light Cone, Scale-Free Cognition, Developmental Bioelectricity, Individuality, TOTE Loop, Infotaxis, Computational Surface, Goal-Directedness
Stance: foundational / theoretical-biology
Relates to: Provides a biological grounding for the multi-scale agency assumptions behind Multi-Agent Systems and Self-Adaptation Self-Expression Self-Awareness ASCENS; the TOTE/homeostasis framing connects to control-loop views in A Composite Self-organisation Mechanism in an Agent Network; informs what “agent” could mean for Myconet Fungi Inspired Superpeer Overlay and bio-inspired coordination.

Tags

A Composite Self-organisation Mechanism in an Agent Network

Reference: Ye, D., Zhang, M., Bai, Q. (2011). WISE 2011, LNCS 6997, Springer. Source file: WISE2011-2.pdf. URL

Summary

The authors propose a decentralized self-organization mechanism that lets agents in a collaborative task-allocation network dynamically adapt their weighted relations (peer-to-peer and subordinate-superior) to improve overall profit. The mechanism combines two components: a Dezert-Smarandache-theory-based trust model that fuses direct experience and neighbor opinions to select candidate partners, and a multi-agent Q-learning algorithm that learns which relation-adaptation actions (enhance/weaken the relation type) pay off.

Unlike prior approaches that assume crisp binary relations, this model uses weighted relation strengths in [0,1], allowing gradual rather than sudden social change. Agents aim to minimize communication, computation, and management cost while maximizing subtask benefit. Reward matrices defined over action pairs couple the two learners so that joint optimal adaptations emerge.

Key Ideas

Weighted relations replace crisp relations for realism.
DSmT trust model fuses self and witness evidence.
Multi-agent Q-learning for joint relation adaptation.
Profit = benefit − (communication + computation + management costs).
Decentralized, resilient to single-node failures.

Connections

Conceptual Contribution

Claim: Decentralised task-allocation networks self-organise more effectively when agents adapt weighted (rather than binary) relations via a composite mechanism that fuses a DSmT-based trust model with multi-agent Q-learning.
Mechanism: Each pair of agents maintains peer-to-peer and subordinate-superior weights in [0,1]. Candidate partners for a subtask are selected using Dezert-Smarandache-theory fusion of direct experience and neighbour opinions (handling conflicting/paradoxical evidence). A multi-agent Q-learning algorithm with coupled reward matrices learns enhance/weaken adaptation actions on those weights, optimising profit = subtask benefit − (communication + computation + management) cost.
Concepts introduced/used: Self-Organisation, Weighted Relation, Dezert-Smarandache Theory, Multi-Agent Q-Learning, Trust Fusion, Relation Adaptation, Task Allocation Network
Stance: engineering
Relates to: Operationalises ideas surveyed in Review on Computational Trust and Reputation Models (witness + direct evidence fusion); complements gossip-style information exchange in Gossip-based Aggregation in Large Dynamic Networks; the decentralised resilience theme echoes Theory of Self-Reproducing Automata.

Tags

Self-Adaptation Self-Expression Self-Awareness ASCENS

On Self-adaptation, Self-expression, and Self-awareness in Autonomic Service Component Ensembles

Reference: Franco Zambonelli, Nicola Bicocchi, Giacomo Cabri, Letizia Leonardi, Mariachiara Puviani (2011). SASO Workshops 2011. Source file: On_Self-Adaptation_Self-Expression_and_Self-Awaren.pdf. URL

Summary

This ASCENS-project position paper frames three research issues for building autonomic service-component ensembles: (i) schemes that enable self-adaptive behavior in individual components and ensembles, (ii) mechanisms for self-expression — dynamic changes to the structure of interaction protocols and coordination topology — and (iii) self-awareness — components knowing enough about context and peers to choose appropriate adaptation schemes.

The authors organize adaptation along two dimensions: where (individual vs. collective) and what (behavioral self-adaptation vs. structural self-expression). A swarm/leader/corridor robotics case study illustrates that different situations call for qualitatively different adaptation regimes, and that moving between regimes requires self-awareness. The paper surveys the state of the art and argues for unified frameworks that span individual and ensemble-level adaptation while keeping human cognitive load manageable.

Key Ideas

Two-dimensional taxonomy of adaptation: where (individual/collective) × what (behavior/structure).
Self-expression = dynamically changing interaction protocols and topology.
Self-awareness as meta-capability enabling choice among adaptation schemes.
Robotics case study: leader, corridor, swarm regimes.
ASCENS roadmap for autonomic component ensembles.

Connections

Conceptual Contribution

Claim: Building autonomic service-component ensembles requires distinguishing three complementary self-* capabilities — self-adaptation (behaviour), self-expression (structure/protocols/topology), and self-awareness (meta-choice among schemes) — along two orthogonal dimensions: individual vs. collective and behavioural vs. structural.
Mechanism: Position paper layout: 2×2 adaptation taxonomy; distinction between self-adaptation and self-expression; robotics case study with three regimes (Leader, Corridor/Peers, Swarm) showing each calls for different adaptation schemes; articulation of four self-awareness sub-issues (understand amount/level of context, capabilities, trade-offs, scheme properties).
Concepts introduced/used: Self-Adaptation, Self-Expression, Self-Awareness, Autonomic Service Component Ensembles, ASCENS, Adaptation Dimensions, Interaction Protocol Change, Meta-Adaptation
Stance: foundational / survey / position
Relates to: Provides the conceptual scaffolding picked up by bio-inspired self-organisation work such as Myconet Fungi Inspired Superpeer Overlay and A Composite Self-organisation Mechanism in an Agent Network; self-awareness thread resonates with agency/Selfhood arguments in Computational Boundary of a Self; protocol-change motif connects to A Scalable Communication Protocol for Networks of LLMs.

Tags

XOR Metric

The distance function d(x, y) = x ⊕ y (interpreted as an unsigned integer) on k-bit identifiers, used as the routing distance in Kademlia. Symmetric (d(x,y) = d(y,x)), satisfies the triangle inequality, and uniquely unidirectional: for any point x and any distance d, there is exactly one point y at distance d from x. This unidirectionality eliminates the asymmetry of Chord’s clockwise routing and is what makes Kademlia’s routing tables symmetric (nodes that route through us also know us).

In this vault

Kademlia

Maymounkov & Mazières’s (2002) Distributed Hash Table organised around the XOR Metric on identifier space, with k-buckets biased toward long-lived nodes, iterative parallel lookups, and opportunistic routing-table maintenance. The DHT underlying BitTorrent Mainline, IPFS / libp2p, Ethereum Discv4/Discv5, Tor hidden services, I2P, and most production P2P systems.

In this vault

Distributed Hash Table

A class of decentralised key-value stores in which data is partitioned across a self-organising network of nodes via Consistent Hashing and a structured overlay routes lookups in O(log N) (or thereabouts) hops. Canonical members: Chord, Kademlia, Pastry, Tapestry. The structured-overlay counterpart of unstructured gossip — DHTs win for lookup with predictable cost; gossip wins for aggregation and dissemination under high churn. DHTs underlie IPFS, Ethereum discovery, BitTorrent’s Mainline DHT, and most P2P content-addressing infrastructure.

In this vault

Chord

Stoica et al.’s (2001) Distributed Hash Table: nodes and keys map to a circular SHA-1 identifier space, each key is owned by its successor, and each node maintains an m-entry finger table (doubling distances) that guarantees O(log N) lookups. The first widely-cited structured P2P overlay; conceptual ancestor of Kademlia, Pastry, Tapestry.

In this vault

Myconet Fungi Inspired Superpeer Overlay

Myconet: A Fungi-Inspired Model for Superpeer-based Peer-to-Peer Overlay Topologies

Reference: Paul L. Snyder, Rachel Greenstadt, Giuseppe Valetto. Drexel University Dept. of Computer Science. Source file: Myconet_A_Fungi_Inspired_Model_for_Super.pdf. URL

Summary

Myconet is a biologically inspired self-organizing overlay-construction protocol for superpeer-based P2P networks, drawing its design from the growth patterns of fungal mycelia. Each node is modeled as a “biomass peer” with a capacity; hyphal peers extend links toward high-capacity regions, branch when saturated, and become immobile superpeers at full utilization. The protocol layers these stigmergic transitions on top of Newscast-style gossip to move biomass toward the highest-capacity peers and dynamically maintain a near-optimal number of well-connected superpeers.

Evaluation shows Myconet converges to approximately optimal superpeer counts across power-law and uniform capacity distributions, reaches ~95% utilization, and self-heals quickly after catastrophic loss of 30-50% of superpeers. It outperforms or matches comparable approaches (SG-1, ERASP) while providing stronger topology stability and resistance to targeted attack on superpeers.

Key Ideas

Biomass peers + hyphal peers + immobile (superpeer) peers with state transitions.
Stigmergy over Newscast gossip for local-only self-organization.
Extension, branching, and absorption rules tuned to heterogeneous capacities.
Near-optimal superpeer count and high utilization under realistic distributions.
Resilience: rapid reconvergence after catastrophic peer loss.

Connections

Conceptual Contribution

Claim: Fungal mycelium growth — biomass flowing along hyphae toward productive regions — is a productive metaphor for self-organising superpeer overlays, yielding topologies that are near-optimal in superpeer count, highly utilised, and resilient to targeted attack.
Mechanism: Models each peer with a capacity and three states (biomass, hyphal extending/branching, immobile superpeer); state transitions driven by local biomass comparisons with neighbours obtained via Newscast gossip; branching hyphae explore new capacity, immobile hyphae absorb biomass up to saturation. Simulation on 10^3–10^6 peers with power-law and uniform capacity distributions shows convergence in ~30-35 rounds and recovery from 50% catastrophic peer loss.
Concepts introduced/used: Stigmergy, Mycelium Model, Hyphal Peer, Biomass, Superpeer Overlay, Newscast Gossip, Self-Organising Topology, Catastrophic Failure Recovery
Stance: empirical / engineering (bio-inspired)
Relates to: Uses the peer-sampling/gossip substrate formalised in Gossiping in Distributed Systems and Gossip-based Aggregation in Large Dynamic Networks; exemplifies the structural/ensemble self-organisation advocated by Self-Adaptation Self-Expression Self-Awareness ASCENS and the bio-inspired cognition of Computational Boundary of a Self.

Tags

Gossip-Based Computation of Aggregate Information

Reference: David Kempe, Alin Dobra, Johannes Gehrke (2003). FOCS 2003 (IEEE Symposium on Foundations of Computer Science). Source file: focs2003-gossip.pdf. URL

Summary

This paper analyzes simple gossip protocols (epidemic-style, randomized pairwise exchanges) for computing aggregate functions — sums, averages, quantiles, random samples — over values held by nodes in highly dynamic distributed systems like P2P networks and sensor networks. The key contribution is the Push-Sum protocol, which distributes weight alongside value so that the ratio stored at each node converges exponentially fast to the true average, even in the face of node failures and message loss.

The second contribution is a precise diffusion speed formalism linking protocol convergence to random walk / Markov chain mixing times, letting the authors analyze uniform gossip, flooding, and other mechanisms uniformly. Push-Sum converges in O(log n + log 1/ε + log 1/δ) rounds with exponentially small message sizes, making it suitable for massive, volatile networks.

Key Ideas

Push-Sum: maintain (value, weight) pairs, exchange halves with random peer; ratio converges to global average.
Mass conservation invariant underlies correctness.
Diffusion speed = convergence rate, mapped to Markov chain mixing times.
Robust to node/link failures — degraded guarantee scales with 1/(1-µ)^2.
Extends to sums, quantiles, random samples, and arbitrary linear syntactic aggregates.

Connections

Gossip Protocols
Multi-Agent Systems
Self-Adaptive Systems
Peer Sampling Service
Large Population Models
CALM Theorem — mass-conservation aggregation is the canonical monotonic primitive
Keeping CALM - When Distributed Consistency is Easy
Monotonic Logic

Conceptual Contribution

Claim: Aggregates (sums, averages, quantiles, random samples) over a massive, volatile network can be computed by simple gossip protocols that converge exponentially fast; a mass-conservation trick (Push-Sum) gives precise averages with only local pairwise exchange.
Mechanism: Introduces Push-Sum (each node maintains a (value, weight) pair and halves on exchange; ratio = average), generalises it to Push-Vector and Push-Synopses for linear synopses; defines diffusion speed connecting protocol convergence to random-walk mixing times on the communication graph; proves O(log n + log 1/ε + log 1/δ) convergence with robustness under message loss and node failure.
Concepts introduced/used: Push-Sum, Mass Conservation, Diffusion Speed, Uniform Gossip, Flooding, Push-Synopses, Random Walks on Graphs, Aggregate Functions
Stance: formal-semantic / foundational (for gossip-based distributed algorithms)
Relates to: Theoretical foundation for Gossip-based Aggregation in Large Dynamic Networks (which re-derives Push-Sum empirically as averaging) and underpins the aggregation primitives surveyed in Gossiping in Distributed Systems and Gossip Protocols; gossip training in Edge Intelligence Survey inherits this analysis.

Tags

Gossip-based Aggregation in Large Dynamic Networks

Reference: Márk Jelasity, Alberto Montresor, Ozalp Babaoglu (2005). ACM Transactions on Computer Systems, Vol. 23, No. 3, pp. 219-252. Source file: gossip.pdf. URL

Summary

The paper presents a proactive, gossip-based protocol for continuously computing aggregate functions (averages, sums, counts, variances, network size, extremal values) over huge dynamic networks such as P2P and grid systems. Each node periodically picks a random neighbor and performs a push-pull exchange; pairwise averaging drives the variance of estimates to zero at a geometric rate while preserving the global mean (“mass conservation”). All nodes thus converge to the correct aggregate and adaptively track changes over time.

Beyond core averaging, the authors show how to compute more complex aggregates (variance, network size via a single seed) and evaluate robustness under node churn and message loss, including a PlanetLab deployment. The protocol is attractive because it is simple, scalable, lightweight, and requires no centralized infrastructure — only a peer-sampling service.

Key Ideas

Push-pull averaging: w_p, w_q ← (w_p + w_q)/2 drives variance to zero exponentially.
Mass conservation preserves global sum so global average remains unchanged.
Reactive vs. proactive aggregation; this work targets proactive, always-on aggregates.
Robustness to dynamism, churn, and message loss.
Underlying assumption: a peer-sampling service supplies uniform random neighbors.

Connections

Gossip Protocols
Self-Adaptive Systems
Multi-Agent Systems
CALM Theorem — push-pull averaging is monotonic, hence coordination-free
Keeping CALM - When Distributed Consistency is Easy

Conceptual Contribution

Claim: A simple push-pull averaging gossip protocol — paired with a peer-sampling service — provides proactive, continuously-updated aggregates (average, sum, count, variance, network size, extrema) at large scale with geometric-rate convergence and robustness to churn and message loss.
Mechanism: Each node periodically picks a random neighbour via getNeighbor(), exchanges local estimate, and replaces both with their average; variance analysis as iterative reduction gives convergence factor independent of network size; adaptive restart mechanism handles dynamism; PlanetLab deployment validates the theory.
Concepts introduced/used: Push-Pull Gossip, Proactive Aggregation, Peer Sampling Service, Variance Reduction, Mass Conservation, Convergence Factor, Adaptive Protocols
Stance: engineering / empirical with formal analysis
Relates to: Practical complement to the theoretical Gossip-Based Computation of Aggregate Information (Push-Sum); cited as a canonical aggregation example in Gossiping in Distributed Systems; the peer-sampling substrate it assumes is the same used by Myconet Fungi Inspired Superpeer Overlay and other bio-inspired overlays.

Tags

Gossiping in Distributed Systems

Reference: Anne-Marie Kermarrec, Maarten van Steen (2007). ACM SIGOPS Operating Systems Review, Vol. 41, No. 5. Source file: Gossiping_in_distributed_systems.pdf. URL

Summary

This tutorial surveys the “gossip revival” in distributed systems, providing a unifying framework for reasoning about the broad space of gossip-based protocols now used far beyond their original role as epidemic reliable multicast. The authors organize gossip protocols by three crucial parameters: peer selection (who to talk to), data exchanged (what to send), and data processing (what to do with what arrives); varying these three gives rise to dissemination, peer sampling, aggregation, overlay/topology construction, resource monitoring, and slicing protocols.

They illustrate each axis with canonical examples — Lpbcast and Newscast for membership, Push-Sum and T-Man for aggregation and overlay construction, Astrolabe for monitoring — and highlight why gossip’s randomized, local-only interactions produce emergent convergent global behavior with exceptional robustness to churn and failures. The paper emphasizes gossip’s use in convergent, not just divergent (epidemic) behaviors.

Key Ideas

Three-parameter gossip framework: peer selection, data exchanged, data processing.
Applications: dissemination, peer sampling, aggregation, topology construction, monitoring, slicing.
Convergent behavior from local random pairwise exchanges.
Peer sampling service is the common substrate most gossip protocols assume.
Robustness through probabilistic redundancy and randomization.

Connections

Conceptual Contribution

Claim: The sprawling family of gossip-based algorithms can be unified as a three-parameter design space — peer selection, data exchanged, data processing — and the same substrate supports not just epidemic dissemination but convergent behaviours including aggregation, overlay construction, and monitoring.
Mechanism: Presents a generic active/passive-thread gossip skeleton; classifies protocols along the three parameters with canonical instances (Lpbcast, Newscast, Cyclon, T-Man, Push-Sum, Astrolabe, GEMS); highlights how peer-sampling acts as the common foundational service enabling higher-level applications.
Concepts introduced/used: Gossip Framework, Peer Selection, Data Exchange, Data Processing, Peer Sampling Service, Convergent Gossip, Epidemic Dissemination, Overlay Construction
Stance: survey
Relates to: Provides the taxonomy that situates Gossip-based Aggregation in Large Dynamic Networks (aggregation), Gossip-Based Computation of Aggregate Information (Push-Sum), Myconet Fungi Inspired Superpeer Overlay (topology construction), and the gossip-training mode surveyed in Edge Intelligence Survey. Anchor for Gossip Protocols hub.

Tags

Exploit Programming - From Buffer Overflows To Weird Machines

Exploit Programming: From Buffer Overflows to “Weird Machines” and Theory of Computation

Reference: Bratus, Locasto, Patterson, Sassaman, Shubina (2011). ;login: The USENIX Magazine, Vol. 36, No. 6 (December 2011). Source file: Bratus.pdf. URL

Summary

This influential ;login: article reframes exploitation research as a discipline of computation theory. The authors trace the evolution from simple stack-smashing (Aleph One) through return-to-libc, return-oriented programming, heap feng shui, and format string exploits, and argue that every such technique amounts to identifying and programming a “weird machine” latent inside a target: an unintended computational model realized by crafted inputs that drive the target’s own code into performing computations its designers never intended.

The essay is dedicated to Len Sassaman and is both a memorial and a manifesto. It argues that “attack papers,” often dismissed as intellectually marginal, are in fact constructive proofs that a target contains a stronger automaton than its designers believed, and thereby exposes incorrect assumptions about the computational nature of the system. Exploitation, in this view, comes full circle to the foundational questions of Church and Turing (“what can a given machine compute?”) and deserves treatment as a rigorous subdiscipline unifying hacker practice with language-theoretic and computation-theoretic analysis.

Key Ideas

Exploits are programs for weird machines instantiated inside a target.
Evolution: stack smashing -> return-to-libc -> ROP -> heap feng shui -> format strings.
“Weird instructions” as attacker-programmable primitives borrowed from target code (strcpy+RET, malloc bookkeeping, printf %n).
Attack papers as constructive proofs of unintended computational power.
Exploitation research as empirical computability theory: “what can this machine actually compute?”
Language- and computation-theoretic methods can redefine weaknesses previously overlooked.
Call to unify hacker craft with academic theory of computation.

Connections

Weird Machine
LangSec
Security Applications Of Formal Language Theory
Shotgun Parsing
Distributed Security
CBCL - Safe Self-Extending Agent Communication — agent-communication ACL designed to preclude weird machines at the parser/expander layer by constraining input to DCFL.

Conceptual Contribution

Claim: Exploitation is the empirical study of unintended computational models (“weird machines”) inside real systems, and brings security research back to the Church-Turing questions of what a given machine can compute.
Mechanism: Reconstructs the history of memory-corruption exploitation as a progression of increasingly general ways to program target-internal weird machines using crafted input data as instructions borrowed from the target’s own code and data-interpretation loops; reinterprets attack papers as constructive proofs presenting a computationally stronger automaton than expected.
Concepts introduced/used: Weird Machine, Exploit Programming, Return-Oriented Programming, Computability, LangSec, Attack Papers
Stance: foundational
Relates to: Companion essay to Security Applications Of Formal Language Theory by the same authors; provides the conceptual vocabulary (Weird Machine) invoked throughout LangSec and pertinent to Agent Security and LLM Agents where crafted prompts or tool inputs similarly instantiate unintended computation (Prompt Injection, Tool Use).

Tags

Security Applications Of Formal Language Theory

Security Applications of Formal Language Theory

Reference: Sassaman, Patterson, Bratus, Locasto, Shubina (2011). Dartmouth College Computer Science Technical Report TR2011-709. Source file: Security Applications of Formal Language Theory.pdf. URL

Summary

This is the foundational LangSec technical report: a sustained argument that the hardest unsolved problems of secure composition (unsafe input handling, mutually intelligible but divergent message interpretations between components) are consequences of ignoring formal language theory in protocol and software design. The authors connect everyday security failures to decidability results: if a protocol’s input language requires recognizers more powerful than necessary (or worse, undecidable), then safely accepting inputs and ensuring identical interpretation across endpoints become theoretically unachievable, producing an endless stream of 0-days that no amount of patching can stop.

Part I develops the formalism, situates exploitation as a constructive proof of unintended computation (“weird machines”), introduces the parse tree differential attack as a systematic technique for finding interpretation mismatches, and applies the framework to SQL validation, PKCS#1 (proven context-sensitive), X.509, ASN.1, and IDS/IPS composition failures. Part II distills the analysis into accessible design principles for protocol designers, developers, and auditors.

The core prescription: keep input languages at the lowest Chomsky level that suffices, build recognizers that fully validate input before any processing, never mix recognition with action (“shotgun parsing”), and ensure identical parsers across endpoints to prevent parser differentials.

Key Ideas

Composition is the primary engineering means and the primary security challenge.
Safely accepting inputs and identically interpreting messages across endpoints are both fundamentally language-theoretic problems.
Undecidable/overpowered input languages yield unfixable vulnerability classes.
Parse tree differential attack: exploiting divergence between implementations of the “same” language.
Weird machines as constructive proofs of unintended computation.
PKCS#1 proven context-sensitive (not regular, not context-free).
Design principles: minimize language power, full recognition before processing, identical parsers at all endpoints, no shotgun parsing.
Critique of “good enough” (80/20) solutions to undecidable problems.

Connections

LangSec
Shotgun Parsing
Weird Machine
Parser Differential
Chomsky Hierarchy
Distributed Security
CBCL - Safe Self-Extending Agent Communication — first ACL designed from these LangSec principles; constrains all messages (including runtime extensions) to DCFL.

Conceptual Contribution

Claim: Insecurity at protocol and component boundaries is a language-theoretic phenomenon: when input languages exceed what recognizers can safely decide, secure composition is impossible, and the resulting vulnerabilities are not bugs but inevitable consequences of design choices.
Mechanism: Analyzes inputs as formal languages; classifies protocols by Chomsky level; shows that context-sensitive or undecidable languages force ad-hoc parsers whose implementation differences enable parse tree differential attacks; demonstrates weird machines as constructive proofs; prescribes minimal-power input languages, full recognition before processing, and identical recognizers at endpoints.
Concepts introduced/used: LangSec, Chomsky Hierarchy, Parser Differential, Shotgun Parsing, Weird Machine, Input Validation, Protocol Design, Distributed Security
Stance: foundational
Relates to: The canonical reference underlying LangSec and Shotgun Parsing in this vault; the theoretical substrate for A Language-Based Approach To Prevent DDoS and for applying parser-theoretic discipline to ACL design (ACL Design Principles, ACL Verifiability) and to Agent Security concerns around message interpretation in LLM Agents and Tool Use settings.

Extensible Distributed Coordination

Reference: Tobias Distler, Christopher Bahn, Alysson Bessani, Frank Fischer, Flavio Junqueira (2015). EuroSys ’15. Source file: eurosys15-edc.pdf. URL

Summary

The paper argues that coordination services such as ZooKeeper and DepSpace, which centralize primitives like locks, leader election, and queues for datacenter services, suffer because their fixed limited interfaces force multi-RPC workarounds that are slow and race-prone. The authors propose extensibility: clients can dynamically install small server-side “recipes” that execute atomically on the coordination kernel’s state, turning multi-step RPC patterns into single efficient operations.

They describe a model where extensions are sandboxed for safety (bounded resource use, determinism, no API extension) and present implementations — Extensible ZooKeeper (EZK) and Extensible DepSpace (EDS) — showing that extensibility increases throughput of a distributed queue by over an order of magnitude (17x for ZK, 24x for DepSpace) without breaking Byzantine fault tolerance or adding significant kernel complexity.

Key Ideas

Limited coordination-kernel APIs force inefficient RPC chains.
Custom extensions execute atomically server-side, like stored procedures for coordination state.
Sandboxing requirements: no API changes, security, determinism, bounded resource use.
Operation extensions vs. event extensions.
Huge throughput gains (17x, 24x) over ZooKeeper/DepSpace.

Connections

Conceptual Contribution

Claim: Coordination kernels (ZooKeeper, DepSpace) are fundamentally limited by fixed primitive APIs that force clients into inefficient multi-RPC workarounds; allowing dynamically-installed, sandboxed, server-side extensions preserves safety while dramatically improving throughput.
Mechanism: Defines an extension model (operation and event extensions) and sandbox requirements (no API modification, security, determinism, bounded resource use); implements EZK (ZooKeeper) and EDS (DepSpace); evaluates four standard recipes (shared counter, queue, barrier, leader election) showing 17-24x throughput gains.
Concepts introduced/used: Coordination Kernel, Server-Side Extensions, Sandboxing, Determinism, Byzantine Fault Tolerance, Stored-Procedure Coordination, Coordination Recipes
Stance: engineering
Relates to: Offers a systems counterpoint to the agent-level coordination abstractions in Coordinating Agents Using ACL Conversations and Multiagent Systems Sycara; shares the extensibility design philosophy of Extensibility in Programming Language Design - Standish applied to distributed state.

Tags

Principled Design Of The Modern Web Architecture

Principled Design of the Modern Web Architecture

Reference: Fielding & Taylor (2000). ICSE 2000. Source file: 337180.337228.pdf. URL

Summary

Fielding and Taylor introduce the Representational State Transfer (REST) architectural style as the abstract model that guided the redesign of HTTP/1.1 and URIs. REST is presented as a coordinated set of architectural constraints (client-server, statelessness, cacheability, uniform interface, layered system, code-on-demand) chosen to meet the needs of an internet-scale distributed hypermedia system.

The paper defines REST’s data elements (resource, representation, metadata, control data), connectors (client, server, cache, resolver, tunnel), and components (origin server, gateway, proxy, user agent), and uses multiple architectural views (process, data, connector) to illustrate how they combine. It then evaluates how well HTTP/1.1 and related Web standards conform to REST, using the style to diagnose architectural mismatches (e.g., cookies, embedded frames).

Key Ideas

REST as an architectural style (set of constraints), not an architecture.
Resources are conceptual, addressed by URIs; representations are transferred.
Statelessness and caching for scalability; uniform interface for generality.
Intermediaries (proxies, gateways) enabled by layered connectors.
Mismatches (e.g., cookies, HTML frames) as REST-style violations.

Connections

Conceptual Contribution

Claim: Internet-scale distributed hypermedia requires a disciplined architectural style - REST - derived from specific constraints rather than any particular implementation.
Mechanism: Decomposes architectures into data elements, connectors, and components; derives REST by incrementally adding constraints (client-server, stateless, cache, uniform interface, layered, code-on-demand); evaluates HTTP/1.1, URIs, cookies, frames against the style.
Concepts introduced/used: REST, Uniform Interface, Statelessness, Layered Systems, Resources, Representations, Architectural Styles, Hypermedia
Stance: foundational
Relates to: Provides the architectural substrate for REST-native agent protocols ACP, Agent-to-Agent Protocol and JSON-RPC Model Context Protocol covered in Survey Of Agent Interoperability Protocols; its uniform-interface constraint contrasts with the performative-rich messaging of KQML/FIPA-ACL.

Tags

Architectural Patterns for Dependable Software Systems - SOL

Specification, Analysis and Implementation of Architectural Patterns for Dependable Software Systems

Reference: Yau, S. S., Mukhopadhyay, S., Bharadwaj, R. (2005). Proc. 10th IEEE Intl. Workshop on Object-Oriented Real-Time Dependable Systems (WORDS’05). Source file: WORD2005-2.pdf. URL

Summary

The paper presents the Secure Operations Language (SOL) and the agent-based SINS middleware for specifying, analyzing, and deploying architectural patterns that realize non-functional requirements (security, fault tolerance, real-time) of distributed dependable systems. SOL is a synchronous specification language with a precise formal semantics supporting automated analysis (theorem proving, model checking); SINS runs SOL agents on virtual machines distributed over hosts, with encrypted inter-agent messaging via a Secure Agent Control Protocol.

The authors illustrate SOL by formalizing a stack safety policy (a safestack module that constrains illegal pushes/pops) and the Hot Standby and Majority Vote fault-tolerance patterns as SOL modules with observable fail events. They extend SOL with module imports, an implicit fail variable, and middleware notification of module failures — enabling compositional dependability reasoning across heterogeneous deployments.

Key Ideas

SOL: synchronous language for agent specification with formal semantics.
SINS middleware runs SOL agents across encrypted VMs.
Patterns (HotStandby, MajorityVote) as reusable SOL modules.
Safety policies enforced at the language level.
Compositional analysis of dependability requirements.

Connections

Conceptual Contribution

Claim: Dependability (security, fault tolerance, real-time) in distributed systems is best achieved by specifying architectural patterns as formal modules in a synchronous agent language and deploying them on a middleware that enforces the same semantics at runtime.
Mechanism: SOL is a synchronous language with precise formal semantics amenable to theorem proving and model checking; programs are agents running on SINS virtual machines across hosts, communicating over the Secure Agent Control Protocol. The authors extend SOL with module imports, an implicit fail variable, and middleware fault notifications, then encode stack-safety, Hot Standby and Majority Vote as reusable SOL modules whose composition preserves dependability guarantees.
Concepts introduced/used: Secure Operations Language, SINS Middleware, Synchronous Language, Architectural Pattern, Hot Standby, Majority Vote, Safestack, Secure Agent Control Protocol, Compositional Dependability
Stance: engineering
Relates to: A concrete agent-middleware realisation of the security calculus in Secure Communications Processing for Distributed Languages; its formal-specification stance meets the language-workbench pragmatics of The Spoofax Language Workbench; pattern reuse echoes dependability concerns in Are Multiagent Systems Resilient to Communication Failures and Theory of Self-Reproducing Automata.

Tags

Agents Secure Interaction in Data Driven Languages

Reference: Mahdi Zargayouna, Flavien Balbo, Serge Haddad. INRETS / LAMSADE / LSV-CNRS. Source file: ladspaper9.pdf. URL

Summary

The authors focus on a distinct class of Multi-Agent Systems where agents coordinate indirectly through a shared, data-driven space (like Linda tuple spaces or Klaim) rather than via point-to-point ACL messaging. They argue existing data-driven coordination languages conflate security with the data layer, leaving no principled way to separate agent-level access-control policies from the shared space. They propose LACIOS (Language for Agent Contextual Interaction in Open Systems), which introduces properties (predicate-based descriptions) and symbolic matching as a richer alternative to tuple templates.

Security in LACIOS is handled as an orthogonal layer of access-control rules expressed in the same language as agent behavior: global rules restrict who may see what, and local rules let each agent hide or expose parts of its own state. The paper gives syntax and informal semantics for spawn/add/update/look primitives and discusses a prototype implementation in Java-LACIOS.

Key Ideas

Tuple-space / data-driven coordination separated from message-passing MAS.
Properties + symbolic descriptions replace rigid tuples.
Security as an orthogonal layer of global/local access rules.
Unified language for behavior and security policies.
Enables fine-grained contextual perception in open MAS.

Connections

Conceptual Contribution

Claim: Data-driven coordination languages (Linda, Klaim, SecSpaces, SecOS) lack a principled separation between application logic and security; a richer, property-based description model with orthogonal access-control rules fixes this without abandoning the shared-space paradigm.
Mechanism: Introduces LACIOS with four primitives (spawn, add, update, look), replaces rigid tuples with descriptions (property→value maps) and symbolic descriptions parameterised by variables; specifies global access rules controlling perception/retrieval and local rules enabling contextual self-hiding by agents; defines process syntax and sketches a Java-LACIOS implementation.
Concepts introduced/used: Data-Driven Coordination, Tuple Spaces, Properties, Symbolic Descriptions, Access Control Rules, Coordination-Security Separation, Open Multi-Agent Systems
Stance: engineering / formal-semantic
Relates to: Extends the Linda/Klaim lineage with a security concern that parallels DAgents Security Book Chapter and Agent Tcl Flexible Secure Mobile Agents but at the coordination-language level rather than the mobile-code level; offers a stigmergic alternative to the message-centric view of Multiagent Systems Sycara.

Tags

Security Kernel Lambda Calculus

A Security Kernel Based on the Lambda-Calculus

Reference: Jonathan A. Rees (1996). MIT AI Laboratory Memo No. 1564. Source file: AIM-1564.pdf. URL

Summary

Rees describes Scheme 48, a programming environment whose design is guided by operating-system security principles. The security kernel is W7, a call-by-value lambda-calculus with extensions for abstract data types, object mutation, and hardware access. Each user or subsystem runs in a separate evaluation environment holding the objects representing that user’s privileges; because environments determine availability of object references, protection and sharing are controlled by construction.

The paper describes experience with Scheme 48 as the programming environment for Cornell’s mobile robots (no underlying OS) and as a secure multi-user workstation environment, arguing that lexical scope + first-class environments are a natural substrate for capability-style security among cooperating agents.

Key Ideas

Lambda-calculus as minimal security kernel via capability-style environments.
Scheme 48 (W7): modules, macros, dynamic isolation, portable across platforms.
Trust mediated by controlling which names bind to which objects.
Authentication via capsules (tamper-proof labelled objects).
Applied to robots and multi-user Scheme environments.

Connections

Conceptual Contribution

Claim: Lexical scope and first-class environments in a lambda-calculus variant (W7) are a sufficient security kernel: protection reduces to controlling which names bind to which object references.
Mechanism: Implements Scheme 48 as a capability-style environment where each user/subsystem runs in its own environment; authentication via capsules (tamper-proof labelled objects); deployed on Cornell mobile robots (no OS) and as multi-user workstation environment.
Concepts introduced/used: Capability Security, Lambda Calculus, Lexical Scope, Scheme 48, Capsules, Distributed Security, Multi-Agent Systems
Stance: foundational / engineering
Relates to: Provides a principled, capability-based alternative to the input-validation discipline of Seven Turrets Of Babel and the static DDoS analysis of A Language-Based Approach To Prevent DDoS; relevant to sandboxing malicious tools described in MalTool Malicious Tool Attacks.

Tags

PKI Layer Cake - Kaminsky Patterson Sassaman

PKI Layer Cake: New Collision Attacks Against the Global X.509 Infrastructure

Reference: Dan Kaminsky, Meredith L. Patterson, and Len Sassaman (2009). Black Hat USA / IOActive technical report. Source file: 1299769.pdf. URL

Summary

Presents several new classes of attacks against the X.509 certificate infrastructure: MD2 preimage exploitation of VeriSign’s still-trusted root, PKCS#10 Subject Name confusion attacks exploiting inconsistent ASN.1 BER parsing between CAs and browsers (multiple CNs, OID leading-zero padding, integer overflow, early null terminators), SQL injection through PKCS#10 subject names, generic SSL client-authentication bypasses, and EV-certificate hijacking via mixed script content.

The paper is largely a case study in how ambiguity at the interface between components — in parsers, in semantics of fields like Common Name, in trust-store EKU handling — turns into exploitable security pathologies. It is of interest to agent-communication research as a cautionary tale about shared-format ambiguity between senders and receivers.

Key Ideas

ASN.1 BER is context-sensitive and handwritten parsers disagree subtly
Subject Name parsing varies across OpenSSL, NSS, CryptoAPI — attacker exploits the gap
MD2 preimage attack enables signature transfer to forged intermediate CA
“Sender-receiver parsing disagreement” as a general attack pattern
Postel’s robustness principle considered harmful for security-critical parsing

Connections

Making Smart Contracts Smarter
Agent Communication Languages
Parser Differential Attack
CBCL - Safe Self-Extending Agent Communication — applies the parser-differential lesson at the message-layer of agent communication; DCFL grammars are class-level unambiguous.

Conceptual Contribution

Claim: The global X.509 PKI is vulnerable not only because of weak hashes (MD2/MD5) but because layered, ambiguously-specified parsers (ASN.1 BER, PKCS#10, Subject Name handling) disagree about what a certificate says — an inter-layer semantic gap exploitable by attackers.
Mechanism: Demonstrate concrete attacks: MD2RSA signature transfer from Verisign’s root, Subject Name Confusion via implementation-dependent CN-selection policies, PKCS#10-tunneled SQL/ASN.1 injection, OID leading-zero/integer-overflow tricks, null-terminator CN spoofing, SSL Client Authentication EKU bypass, and EV hijacking via mixed-trust scripting.
Concepts introduced/used: Parser Differential, Parser Differentials, X.509 PKI, ASN.1 BER Ambiguity, Certificate Authorities, Protocol Layering Attacks, Distributed Security, LangSec, Language-theoretic Security, Postel’s Robustness Principle
Stance: empirical / security-critique
Relates to: Canonical case study for Distributed Security and a prime example of why A Language-Based Approach To Prevent DDoS-style disciplined parsing matters. The ambiguity of ASN.1 BER mirrors the semantic-drift concerns in agent communication languages (A Common Ontology Of ACLs, ACL Rethinking Principles) — when two parties disagree about message meaning, security or coordination fails.

Tags

SPKI-SDSI

SPKI / SDSI: A Simple Distributed Security Infrastructure with Linked Local Names

Reference: Rivest, R. L. & Lampson, B. (1996). SDSI — A Simple Distributed Security Infrastructure. (Working document, MIT.) Followed by: Ellison, C., Frantz, B., Lampson, B., Rivest, R., Thomas, B. & Ylonen, T. (1999). SPKI Certificate Theory. RFC 2693, IETF. (Also: Clarke, D. E., Elien, J.-E., Ellison, C., Fredette, M., Morcos, A. & Rivest, R. L. (2001). Certificate Chain Discovery in SPKI/SDSI. Journal of Computer Security 9(4).) Open access (RFC 2693) · SDSI 1.0 (Rivest-Lampson, MIT) · Chain discovery (Elien MIT MS thesis 1998)

Summary

Rivest, Lampson, Ellison and the SPKI working group develop SPKI/SDSI, a public-key infrastructure that takes a sharply different stance from the X.509 / hierarchical-CA tradition: instead of a global namespace of certified identities rooted in a chain of certificate authorities, SPKI/SDSI gives each principal its own local namespace and certificates that bind keys to authorisations rather than identities. SDSI’s central innovation is linked local names: K_alice's friends is a name in K_alice’s namespace; K_alice's friends's secretary is a chain of links — no global registry needed. Authority delegation is similarly local: a certificate K_a → K_b : auth issued by K_a grants authority auth to K_b, optionally with delegation rights. Authority is what matters, not who — a distinction Lampson summarised as “we’re moving from authentication to authorization.” The SPKI Certificate Theory (RFC 2693) formalises this: certificates are 5-tuples <Issuer, Subject, Delegation, Authority, Validity>; chain discovery (Clarke et al. 2001) gives a sound and complete algorithm for deriving “does this principal have this authority?” from a collection of certificates. The design directly anticipates modern decentralised identity / object-capability composition: SPKI/SDSI is the conceptual bridge between the object-capability tradition (E, Spritely) and the cryptographic-identity tradition (X.509, PGP). DIDs and Verifiable Credentials inherit substantial conceptual machinery from SPKI/SDSI; Macaroons (Birgisson et al. 2014) are SPKI-style attenuable capability tokens for HTTP APIs.

Key Ideas

Authorization, not authentication: certificates bind keys to authorities — what the principal is permitted to do — rather than to identities. The question “who is this key?” is replaced by “what is this key allowed to do?”
Local namespaces (SDSI): each principal has its own namespace; names are local identifiers like K_alice's bob, with no global resolution. Linked local names chain across namespaces: K_alice's bob's friends resolves through K_alice’s and then K_bob’s namespaces.
Delegation as a first-class certificate field: a certificate may grant authority with or without the right to re-delegate; chains of delegated certificates are the principal authority-derivation mechanism.
5-tuple certificates: <Issuer, Subject, Delegation-flag, Authorization-S-expression, Validity> (RFC 2693 §2.4 calls the field “Authorization”, not “Authority”); the Authorization is an S-expression in a structured language (action, object, qualifier) that supports rich access-control specifications.
Chain discovery (Clarke et al. 2001): given a goal K_principal has authority A, the chain-discovery algorithm searches the certificate collection for a derivation; sound and complete; polynomial in the size of the certificate collection for many practical fragments.
No mandatory identity binding: certificates may bind keys to local names (SDSI-style) or directly to authorisations (SPKI-style) — identity is just one kind of authority. The system can be used without ever assigning a global “real name” to a key.
Capability composition: SPKI authorities compose under intersection and chain; the resulting authority is the most-restrictive intersection along the chain. This is exactly the capability-security composition rule lifted to a certificate-based distributed setting.

Connections

Conceptual Contribution

Claim: A distributed security infrastructure should bind cryptographic keys to authorisations (what they may do) rather than to identities (who they “really” are); each principal should have its own local namespace; authority delegation should be first-class with an explicit chain-discovery algorithm. The X.509 hierarchical-CA model is the wrong fit for most distributed-system access-control needs.
Mechanism: 5-tuple certificate format (issuer / subject / delegation / authority / validity); local namespaces with linked-local-names resolution; sound and complete chain-discovery algorithm; authority composition under intersection.
Concepts introduced/used: SPKI, SDSI, Linked Local Names, Capability Certificate, Authority-not-Identity, Chain Discovery.
Stance: foundational systems-design paper / IETF specification.
Relates to: Direct conceptual bridge between the object-capability tradition (Dennis & Van Horn 1966, EROS, the E-language line in Miller 2006) and the cryptographic-identity tradition (X.509, PGP). SPKI/SDSI explicitly takes the capability stance — unforgeable name = capability — and lifts it into a distributed cryptographic setting where the unforgeability comes from the public-key cryptography rather than from memory protection. The Macaroons paper (Birgisson, Politz, Erlingsson, Taly, Vrable & Lentczner 2014) is SPKI/SDSI’s most-deployed modern descendant: HMAC-chained authority tokens with attenuation, used in production at Google and elsewhere. Modern decentralised-identity standards — W3C DIDs, Verifiable Credentials, the Authorization Capabilities (zCaps) work — inherit substantial conceptual machinery from SPKI/SDSI even when they do not cite it directly. Within this vault, SPKI/SDSI is the missing distributed-cryptographic counterpart of the in-process capability work in Capability Myths Demolished and Robust Composition - Towards a Unified Approach to Access Control and Concurrency Control — it is what those frameworks become when keys cross machine boundaries. The Lowe/PKI Layer Cake - Kaminsky Patterson Sassaman-style critiques of X.509 PKI are simultaneously arguments for SPKI-style local-name systems: parser differentials and the trust-collapse-by-CA-misissuance problem largely vanish when certificates bind authority rather than identity.

Tags

#capability-security #spki #sdsi #pki #distributed-security #authorisation #foundations

Speaks-For Calculus

Lampson–Abadi–Burrows–Wobber’s (1992) formalism for distributed authentication, delegation, and who is entitled to assert what on whose behalf. The primitives are says (principal A asserts statement s, written A says s) and speaks-for (A ⇒ B — anything A says, B says). The principal algebra is rich: atomic principals (users, processes, keys), conjunction A ∧ B, quoting A | B (A speaking on behalf of B), roles A as R, and for-channel A for K. Speaks-for facts are witnessed by signed certificates; authentication is checking chains of certificates from a trusted root. Access control then grants rights to principals at any level of compoundness. The calculus is the formal vocabulary underlying SPKI/SDSI, DIDs and Verifiable Credentials, modern attribute-based authorisation, and any system that needs to reason about delegated commitment.

In this vault

Authentication in Distributed Systems - Lampson Abadi Burrows Wobber — the founding paper
A Logic of Authentication — BAN Logic (1990) for protocol-level reasoning
Spi Calculus — pi-calculus with cryptography
SPKI-SDSI — capability-style PKI built on speaks-for
Decentralized Identifiers
Capability Myths Demolished
Programming Semantics for Multiprogrammed Computations — the Object Capability dual view
The Heart of Spritely - Distributed Objects and Capability Security
An Ontology for Commitments in Multiagent Systems - Singh — delegated commitments
Distributed Security
Agent Infrastructure
CBCL - Safe Self-Extending Agent Communication — signed-verdict architecture

Authentication in Distributed Systems - Lampson Abadi Burrows Wobber

Authentication in Distributed Systems: Theory and Practice

Reference: Lampson, B., Abadi, M., Burrows, M., & Wobber, E. (1992). Authentication in Distributed Systems: Theory and Practice. ACM Transactions on Computer Systems (TOCS) 10(4): 265–310. November 1992. (DEC SRC Report 83, 1992.) URL (Microsoft Research) · DOI

Summary

The ABLP paper (named for Abadi–Burrows–Lampson–Plotkin’s later refinement, but originating here) introduces the speaks-for calculus: a clean formal vocabulary for distributed authentication, delegation, and who is entitled to assert what on whose behalf. The setting: a distributed system in which principals (users, processes, machines, services) send requests that must be authorised. The traditional access-control question — is this principal allowed to perform this action on this object? — presupposes a prior question the paper answers: who is the principal whose request this is? That prior question becomes hard once requests pass through delegation chains (a user logs in to a workstation, which authenticates to a file server, which calls a database service on the user’s behalf): authentication is no longer one-to-one between principal and request but a chain of compound principals.

The technical heart of the paper is the speaks-for relation A ⇒ B: principal A speaks for principal B means that any statement A makes can be treated as if B had made it. Speaks-for is reflexive, transitive, and closed under conjunction and group membership. From A ⇒ B and A says s, the system derives B says s. Compound principals are built from atomic ones via conjunction (A ∧ B says s requires both to assert s), quoting (A | B says s means A is making a statement on behalf of B, but A retains responsibility), roles (A as R is A acting in role R), and for-channel (A for K is A speaking over channel/key K). The calculus is implementable: speaks-for facts are encoded in signed certificates, the access-control matrix grants rights to principals at any level of compoundness, and authentication reduces to checking a chain of certificates.

For the agent communication and security agenda this vault tracks, the speaks-for calculus is the formal vocabulary for delegated commitments and signed credentials. When agent B accepts a commitment from a process speaking on A’s behalf, the question “did A really commit?” is answered by the speaks-for chain witnessed by the credential. The paper is the philosophical and engineering ancestor of SPKI/SDSI (Rivest–Lampson–Ellison’s capability-style PKI, which Lampson designed using the speaks-for vocabulary), DIDs and Verifiable Credentials, object-capability facets, and modern attribute-based authorisation. For CBCL, speaks-for is the natural answer to “who signed this commitment?” — the dialect contract specifies which principals may emit which verdicts under which delegation rules, and the speaks-for chain provides the proof.

Key Ideas

Principals are first-class: a principal is anything that can make a statement — users, processes, machines, services, public keys, roles, groups, conjunctions, quotations. The system reasons uniformly about all of them.
The says operator: A says s is the primitive — principal A has asserted statement s. Authentication delivers says judgements; authorisation uses them.
The speaks-for relation: A ⇒ B means everything A says, B says. Reflexive, transitive, closed under conjunction. The delegation primitive.
Compound principals: built by conjunction (A ∧ B), quoting (A | B — A speaking on behalf of B), roles (A as R), and for-channel (A for K). A workstation acting on behalf of a user over a particular key is a compound principal at the leaf of an authentication chain.
Certificates as speaks-for witnesses: a signed certificate stating K ⇒ A (this key speaks for that principal) is the wire-format proof of a speaks-for fact. Authentication is verifying a chain of such certificates.
Access control on compound principals: the access-control list grants rights to principals at any level — Alice as Admin, Workstation | Alice for K, Group(Engineers). The complex authorisation patterns of real systems become tractable.
Trusted Computing Base separation: each principal has its own TCB; speaks-for chains let one principal delegate trust to another without fully merging TCBs.
Implementable: the paper describes the Taos system (DEC SRC) implementing the calculus; the design influenced Windows NT’s authentication architecture.

Connections

Conceptual Contribution

Claim: Distributed authentication and delegation can be cleanly formalised by the speaks-for relation A ⇒ B over a rich algebra of principals (atomic, conjunction, quoting, role, for-channel) together with the says operator. Authorisation reduces to checking that the speaker’s principal-expression has been granted rights to perform the requested action.
Mechanism: Define principals as a recursive algebra (atomic, A ∧ B, A | B, A as R, A for K). Define A says s (primitive) and A ⇒ B (speaks-for, reflexive-transitive-conjunctive). Encode speaks-for facts as signed certificates; authentication chains certificates from a trusted root to the requesting principal. Access-control lists grant rights to any principal expression; the request is authorised iff the deduced speaker’s principal is on the ACL. Implement the calculus in the Taos distributed OS as a concrete proof of practicality.
Concepts introduced/used: Speaks-For Calculus, ABLP Logic, Says Operator, Compound Principal, Quoting Principal, Role Principal, Delegation, Access Control List, Trusted Computing Base.
Stance: foundational technical paper / industry-grade reference design.
Relates to: The formal vocabulary that makes SPKI/SDSI (Rivest–Lampson–Ellison) intelligible: SPKI is the speaks-for calculus packaged as a PKI. DIDs and VCs inherit the same algebraic structure. Object capabilities (Dennis–Van Horn / EROS / Miller) are a dual view of the same problem (rights attached to objects rather than chains of delegation); the Spritely / OCapN line composes both views. For agent communication, speaks-for is the natural vocabulary for delegated commitments: when an agent’s process commits on the agent’s behalf, the speaks-for chain witnesses authority. The pair with Singh 1999 is direct: commitments without authority chains are weak, and authority chains without commitments are unactionable. CBCL’s signed-verdict architecture is a speaks-for application: the dialect contract names which principals may emit which verdicts under which delegation rules. The cryptographic complement is BAN logic (1990) and Spi calculus (1997) — BAN reasons about protocol soundness, ABLP reasons about who.

Execution Monitor

Runtime mechanism that observes a program’s actions and intervenes when policy is violated; the Security Automaton is the canonical formal model. Implemented in practice as an Inlined Reference Monitor or out-of-process supervisor.

In this vault

Enforceable Security Policies - Schneider

Enforceable Security Policies

Reference: Schneider, F. B. (2000). Enforceable Security Policies. ACM Transactions on Information and System Security (TISSEC) 3(1): 30–50. February 2000. URL (Schneider’s Cornell page) · DOI

Summary

Schneider’s paper is the theoretical backdrop for trace-monitor enforcement — the move that takes a stated security policy and asks, formally, can this policy be enforced by a mechanism that observes program execution one step at a time and halts execution if a violation is about to occur? The answer is only if the policy is a safety property: precisely, the policies enforceable by an execution monitor (EM) are exactly those whose violations are finite-prefix detectable. Liveness properties — “good thing eventually happens” — cannot be enforced by monitoring, because no finite prefix witnesses violation. Schneider formalises EM enforcement as a class of security automata — automata that read the program’s execution one event at a time, transitioning over states that encode the policy’s history, and halting the program upon entering a no-good state.

The result has three teeth. First, it gives a precise, decidable characterisation of the enforceable policies: EM-enforceable iff specifiable as a safety property over execution traces. Second, it cleanly separates the policy (the security automaton) from the mechanism (the EM machinery that interposes between the program and its environment), so the same EM machinery can enforce many policies by swapping the automaton. Third, it lays the groundwork for inlined reference monitors and security-typed languages (Schneider’s later work with Erlingsson on SASI, Ligatti–Bauer–Walker on edit automata that generalise EM with transformation in addition to halting).

For the architecture this vault tracks, Schneider is the formal warrant for CBCL’s R5 monotone-verdict trace monitor and for session-type monitorability in general. CBCL’s invariant — only emit monotone verdicts — is the safety-property restriction: a CBCL verdict is a finite-prefix witness, the verdict ledger is the security automaton’s state, and the host’s enforcement is precisely an EM in Schneider’s sense. The paper also bounds what CBCL cannot do: liveness properties (every commitment is eventually discharged) are not EM-enforceable, only EM-monitorable for violation of safety lower bounds (e.g. a deadline expires → record commitment broken). The CBCL discussion section should cite Schneider for the formal precision and Ligatti–Bauer–Walker for the edit-automaton generalisation if transformations are wanted.

Key Ideas

Execution Monitor (EM) enforcement: a mechanism that observes program execution one event at a time and halts execution if continuing would violate the policy. Standard examples: reference monitors, system-call interposition, security wrappers.
Safety-property characterisation: EM-enforceable policies are exactly the safety properties — properties whose violations are detectable on a finite prefix of execution. Liveness properties cannot be EM-enforced.
Security automata: a formal model for EM enforcement. A security automaton is a (possibly infinite-state) automaton that reads execution events, maintains policy-relevant history, and transitions to a “no-good” state on violation; the EM halts the program at that point.
Policy / mechanism separation: the security automaton specifies what is enforced; the EM machinery enforces how. Swapping automata changes the policy without changing the enforcement infrastructure.
Liveness is out of scope: properties like “every request is eventually served” cannot be EM-enforced because no finite prefix witnesses violation. They can be monitored for violation of finite-bounded safety approximations (e.g. timeout-deadline as a safety surrogate).
Anti-Rice (constructively): Rice tells us most semantic properties of programs are undecidable, but EM enforcement sidesteps Rice by limiting attention to properties expressible as runtime-checkable trace predicates rather than as program properties.
Genealogical successors: Ligatti–Bauer–Walker edit automata generalise EM by allowing the monitor to transform events (insert, suppress, replace), enlarging the enforceable class beyond pure safety to certain renewal properties; inlined reference monitors (Erlingsson–Schneider SASI) move the EM machinery into the program text itself.

Connections

Conceptual Contribution

Claim: A security policy can be enforced by an execution monitor (a mechanism that observes one event at a time and halts on impending violation) iff it is a safety property — i.e., its violations are detectable on a finite prefix of execution. Liveness properties cannot be EM-enforced.
Mechanism: Define EM enforcement formally: a (possibly infinite-state) security automaton reads execution events, maintains policy-relevant history, transitions on each event, and signals “no-good” on violation; the EM halts the program at the signalling step. Show that the class of policies so enforceable is exactly the safety properties (in the Alpern–Schneider sense). Separate the automaton (policy) from the EM machinery (mechanism), enabling policy-parametric enforcement.
Concepts introduced/used: Execution Monitor (EM), Security Automaton, Safety Property, Liveness Property, Trace Property, Inlined Reference Monitor, Edit Automaton (Ligatti–Bauer–Walker generalisation).
Stance: foundational technical paper.
Relates to: The formal warrant for CBCL’s R5 monotone-verdict trace monitor — CBCL verdicts are finite-prefix witnesses, the verdict ledger is the security automaton’s state, and host-side enforcement is exactly an EM. The paper also bounds what trace-monitor enforcement can do: liveness properties (every commitment eventually discharged) are not enforceable, only approximable via timeout-deadline safety surrogates. Pairs naturally with Necula’s PCC (static proof-bearing artefacts) — Schneider tells you which dynamic properties are runtime-monitorable, PCC tells you which static properties can be discharged at load time by a proof-checker. The genealogical successors are inlined reference monitors (Erlingsson–Schneider), edit automata (Ligatti–Bauer–Walker), and the entire runtime-verification literature. The LangSec pair is conceptually adjacent: LangSec restricts the input language so safety is decidable at parse time; Schneider’s EM restricts the enforced policy class so safety is decidable at runtime. monitorability of session types is the direct session-type analogue. The deeper conceptual map: Schneider is to runtime enforcement what Hoare is to static specification and PCC is to load-time proof-checking.

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.

Proof-Carrying Code - Necula

Proof-Carrying Code

Reference: Necula, G. C. (1997). Proof-Carrying Code. In Proceedings of the 24th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’97), Paris, January 1997, pp. 106–119. ACM. URL (author’s Berkeley page, original PostScript) · URL (Illinois course PDF mirror) · DOI (ACM)

Summary

Proof-Carrying Code (PCC) is the architectural ancestor of every “ship a proof with the artefact, verify the proof rather than re-deriving safety from scratch” pattern in the modern security stack — including CBCL’s R4 split (host runs a small certified verifier on each dialect contract proof), CIVeX certificates (causal-identifiability artefacts shipped from prover to host), BAN-style protocol soundness certificates, and TEE attestations. The premise is direct: untrusted code arrives at a host that must run it under a safety policy (no out-of-bounds memory access, no division by zero, no privilege escalation, only sanctioned syscalls). Re-deriving safety on every load is expensive (general program analysis is undecidable, conservative approximations reject too much real code) and shifts trust onto the host’s analyser. PCC inverts the burden: the code producer generates a machine-checkable proof that the code respects the policy, and the code consumer checks the proof. Proof checking is mechanical, syntactic, decidable, and cheap; proof finding (the work that produced the proof) is hard and lives on the producer’s side.

The technical content of the paper is the framework that makes this practical. Necula defines a safety policy as a set of rules in a first-order theory over machine states; programs come accompanied by a safety predicate whose proof in this theory entails the policy. Proofs are encoded in a logical framework (LF / Edinburgh Logical Framework), so the proof-checker is a single, small, generic LF type-checker independent of the safety policy. Necula demonstrates the architecture on a packet-filter benchmark: a Berkeley Packet Filter untrusted assembler program is verified to terminate, stay in bounds, and call no syscalls — by checking ~5 KB of LF proof against the BPF policy, in milliseconds. The signal is that the verifier is tiny and policy-parameterised; safety becomes a function of proof checkability rather than of expensive whole-program analysis.

For the security agenda this vault tracks, PCC is foundational in three respects. First, it generalises capability-secure thinking (Dennis & Van Horn 1966, Shapiro et al.) from access control to behavioural conformance: the proof is a behavioural capability the producer holds, the verifier is the gatekeeper. Second, it operationalises Rice’s theorem in a constructive direction — Rice says semantic properties of arbitrary programs are undecidable, but PCC shows that with a proof in hand, checking that the proof establishes the semantic property is trivial. Third, it is the architectural pattern that CBCL’s R4 split inherits literally: a CBCL dialect contract is the code, a Lean 4 proof that the contract is well-formed and policy-respecting is the certificate, and the host’s small Lean kernel check is the PCC verifier. The discussion section of any CBCL/CIVeX paper should cite PCC explicitly.

Key Ideas

Ship the proof with the artefact: the code producer (who knows why the code is safe) generates a proof; the code consumer checks the proof. Proof-checking is cheap, mechanical, syntactic, and decidable; the finding of proofs is hard and lives on the producer’s side.
Safety policy = first-order theory: a safety policy is a set of inference rules in a first-order theory over machine states and operations. Programs come with a safety predicate; a proof of the predicate in the theory entails the policy.
Logical Framework as the proof carrier: proofs are LF terms (Edinburgh Logical Framework). The verifier is an off-the-shelf LF type-checker — small, generic, policy-parameterised. Trusted code base: the LF type-checker plus the policy rules.
Asymmetry of effort: producer effort scales with program complexity; consumer effort scales with proof size, which is bounded by program size in practice but does not depend on the difficulty of the underlying analysis.
Decoupling of policy from verifier: changing the safety policy means changing the inference-rule set; the LF checker is reused unchanged. New policies can be deployed without re-validating the verifier.
No trust in the producer: a malicious producer can submit malicious code, but cannot generate a verifiable proof for it (under soundness of the policy). The producer is untrusted; the verifier is the trust anchor.
Packet-filter benchmark: BPF programs, originally trusted via interpretation in a kernel sandbox, are PCC-verified to be safe to run as native code. Verification cost drops from microseconds-per-packet (interpreter) to a one-time millisecond proof check at load time.
Generalises to many policies: type safety, memory safety, resource bounds, information-flow control, even fine-grained behavioural contracts — all expressible as PCC safety policies.

Connections

Conceptual Contribution

Claim: Safe execution of untrusted code under a stated safety policy can be achieved by having the code producer ship a machine-checkable proof of policy compliance with the code, and having the code consumer check the proof rather than re-derive safety. This inverts the standard burden: hard-to-derive properties become trivial-to-check given the right artefact.
Mechanism: Express the safety policy as a first-order theory over machine states; require submissions to include a proof of the program’s safety predicate; encode proofs in a Logical Framework (LF) so the consumer-side checker is a generic LF type-checker independent of the policy. The trusted code base is the LF checker plus the policy rules; the producer is untrusted. Demonstrated on the Berkeley Packet Filter, where PCC verification runs in milliseconds at load and replaces interpreter-based sandboxing.
Concepts introduced/used: Proof-Carrying Code, Safety Policy, Safety Predicate, Logical Framework (LF), Producer-Consumer Asymmetry, Verifier, Trusted Code Base, Behavioural Capability.
Stance: foundational technical paper / architectural pattern.
Relates to: The architectural ancestor of CBCL’s R4 split — dialect contracts are shipped with Lean 4 proofs of well-formedness and policy compliance; the host’s small Lean kernel check is the PCC verifier. PCC is the citation for “ship the proof, check the proof.” Operationalises Rice’s theorem in a constructive direction: undecidable in general, decidable with the producer’s proof in hand. The natural pair is Schneider 2000 — Schneider characterises which policies are enforceable by trace monitoring; PCC characterises how a code consumer can verify static policies without re-deriving them. The verification heritage runs through Hoare 1969 / Floyd (axiomatic semantics and inductive assertions) to PCC’s LF-encoded proofs. The LangSec tradition (Sassaman et al.) is the dual move: restrict the input language so safety becomes decidable without a producer-side proof. CBCL combines both: a DCFL surface (LangSec) with proof-carrying dialect contracts (PCC).

The Halting Problems of Network Stack Insecurity

Reference: Sassaman, Patterson, Bratus, Shubina (2011). ;login: (USENIX), Vol. 36, No. 6. Source file: The_Halting_Problems_of_Network_Stack_In.pdf. URL

Summary

The paper founds language-theoretic security (LangSec) on a startling thesis: accepted/valid inputs to a program form an input language, and a program’s input-handling code is effectively a recognizer for that language. Insecurity arises when this recognizer problem is computationally too powerful — recognizing context-sensitive or Turing-complete input languages makes validity checking undecidable, so exploitable mismatches between the intended and actual recognizer are inevitable.

Through examples (X.509 ASN.1 parsing, SQL injection, network-stack fingerprinting, 802.15.4 SFD attacks, qmail), the authors show how handwritten ad-hoc recognizers introduce “weird machines” on which crafted inputs execute exploit programs. They propose two principles: (1) Starve the Turing beast — give parsers only the minimum computational power needed; (2) Secure composition requires parser computational equivalence. They argue HTML5’s Turing-completeness regresses safety, and JSON/S-expressions exemplify the right design.

Key Ideas

Inputs form a formal language; parsers are recognizers.
Undecidability of input validity => unexploitable security impossible.
Exploits run on “weird machines” built from crafted inputs.
Minimal computational power principle (a LangSec Least Privilege).
Postel’s robustness principle harmful for security.

Connections

Language Workbenches
LangSec
Parser Differential
Protocol Documents
Agent Communication Languages
Multi-Agent Systems
An Unsolvable Problem of Elementary Number Theory — Church 1936, the undecidability result the title invokes.
Recursively Enumerable Sets of Positive Integers and Their Decision Problems — Post 1944, decision-problem framing behind the recognizer view.
Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I — Gödel 1931, the incompleteness ancestor of the LangSec impossibility argument.
CBCL - Safe Self-Extending Agent Communication — applies the “starve the Turing beast” principle to agent-communication languages: DCFL-bounded inputs, including runtime extensions.

Conceptual Contribution

Claim: Much network-stack insecurity is a consequence of treating input validation as an ad-hoc engineering task rather than as a formal recognition problem; if the input language is too powerful, safe validation is undecidable and exploitable “weird machines” are inevitable.
Mechanism: Sassaman et al. recast every parser as a recognizer for a formal language and map concrete vulnerability classes (ASN.1 in X.509, SQL injection, TCP/IP fingerprint ambiguity, 802.15.4 SFD spoofing, qmail overflows) onto the Chomsky hierarchy. They derive two design principles — starve the Turing beast (keep parsers minimal: regular/context-free where possible) and require computational equivalence of parsers for secure composition — and argue Postel’s robustness principle exacerbates the problem.
Concepts introduced/used: LangSec, Weird Machine, Input Language, Recognizer, Chomsky Hierarchy, Parser Equivalence, Postel’s Law Critique, Halting Problem
Stance: foundational
Relates to: Frames the security motivation behind language-workbench approaches like The Spoofax Language Workbench and the language-based DDoS defence in A Language-Based Approach To Prevent DDoS; its recognizer view complements the calculus-level security of Secure Communications Processing for Distributed Languages.

Tags

A Language-Based Approach To Prevent DDoS

A Language-Based Approach to Prevent DDoS Attacks in Distributed Financial Agent Systems

Reference: Fazeldehkordi, Owe, Ramezanifarkhani (2018). University of Oslo. Source file: A language-based approach to prevent DDoS attacks in distributed financial agent systems.pdf. URL

Summary

The authors propose adding a language-based layer of defense against DoS/DDoS to distributed financial agent systems built on the actor model with asynchronous method calls and futures (in the style of Creol/ABS). Because such languages make it cheap to launch non-blocking floods, they adapt a static analysis for detecting call-flooding cycles to the many-to-one DDoS setting.

The analysis builds per-method control-flow graphs, identifies cycles, and classifies nodes as strongly- or weakly-reachable to detect unbounded method-call generation at compile time. They distinguish one-to-one, many-to-one, and one-to-many flooding, and illustrate with a publish/subscribe newsletter example where future-based optimization accidentally enables a DoS against subscribers.

Key Ideas

Static detection of call-based flooding in actor-model languages with futures.
Classification: one-to-one, many-to-one, one-to-many flooding.
Strong vs weak reachability in control-flow cycles.
Instantiation flooding (unbounded object creation) as a resource-exhaustion vector.
Application to financial service subscriber systems.

Connections

Conceptual Contribution

Claim: Actor-based agent languages with asynchronous futures make DoS/DDoS cheap to launch inadvertently, and static analysis of call-flow cycles can prevent it at compile time.
Mechanism: Builds per-method control-flow graphs, detects strongly/weakly-reachable cycles that generate unbounded calls; extends from one-to-one to many-to-one and one-to-many flooding; illustrated on a Creol/ABS publish/subscribe newsletter.
Concepts introduced/used: Static Analysis, Actor Model, Futures, DDoS, Control-Flow Graph, Distributed Security, Multi-Agent Systems
Stance: engineering
Relates to: Shares the language-level-security stance of Seven Turrets Of Babel and Security Kernel Lambda Calculus; addresses a threat class complementary to the tool-level attacks of MalTool Malicious Tool Attacks and the broad landscape of AI Agents Under Threat.

Tags

Secure Communications Processing for Distributed Languages

Reference: Abadi, Fournet, Gonthier (1999). Compaq SRC / Microsoft Research / INRIA technical paper. Source file: Secure_communications_processing_for_dis.pdf. URL

Summary

Abadi, Fournet, and Gonthier formalize communications processing — the marshaling, unmarshaling, and cryptographic operations that wrap distributed language primitives like RPC and RMI — within a process calculus. They study how local communication semantics (single machine or protected network) can be extended transparently to hostile distributed networks through a generic cryptographic “wrapper” that operates like a firewall with an encrypting tunnel.

The technical core uses the join-calculus and its cryptographic extension, the sjoin-calculus, to translate high-level join-calculus processes into protected low-level sjoin-calculus processes that exchange encrypted messages. They prove a full-abstraction theorem showing the wrapping preserves observational equivalence — attackers on the public network cannot distinguish wrapped processes that behave the same locally.

Key Ideas

Join-calculus as basis for concurrent/distributed language semantics.
Sjoin-calculus adds symmetric encryption primitives.
Wrapper as filter/firewall doing marshaling + encryption uniformly.
Full-abstraction theorem: wrapping preserves equivalences.
Security reasoned compositionally across distribution boundaries.

Connections

Conceptual Contribution

Claim: The communications-processing layer of a distributed language (marshalling + crypto) can be compiled automatically from a local-semantics specification in such a way that distribution becomes observationally transparent even under an active network attacker.
Mechanism: Abadi, Fournet and Gonthier use the join-calculus for local semantics and the sjoin-calculus (join + symmetric crypto primitives) for the low-level network, defining a wrapper translation that implements channel communication via encrypted tunnels gated by a firewall-like filter. A full-abstraction theorem proves that two source programs are observationally equivalent iff their wrapped versions are, so security reasoning composes with functional reasoning.
Concepts introduced/used: Join Calculus, Sjoin Calculus, Full Abstraction, Communications Processing, Cryptographic Wrapper, Observational Equivalence, Marshalling
Stance: formal-semantic
Relates to: Provides the calculus-level counterpart to language-engineering security efforts like The Halting Problems of Network Stack Insecurity and A Language-Based Approach To Prevent DDoS; its transparent-distribution agenda links to the actor-style transparency claims of Programming Erlang Second Edition and the SOL/SINS encrypted inter-agent channels in Architectural Patterns for Dependable Software Systems - SOL.

Tags

DAgents Security Book Chapter

D’Agents: Security in a Multiple-Language, Mobile-Agent System

Reference: Robert S. Gray, David Kotz, George Cybenko, Daniela Rus (1998). Mobile Agents and Security (G. Vigna, ed.), Springer LNCS. Source file: gray-security-book.pdf. URL

Summary

This chapter describes the security architecture of D’Agents (formerly Agent Tcl), a mobile-agent system whose agents can be written in Tcl, Java, or Scheme. The authors frame mobile-agent security as four interrelated problems: protecting the host machine from malicious agents, protecting agents from each other, protecting an agent from a malicious machine, and limiting aggregate resource consumption across groups of machines.

For machine and inter-agent protection, D’Agents relies on PGP-based cryptographic authentication of owners, identity-based resource managers that enforce access-control policies, and secure execution environments (Safe Tcl, Java security managers, Scheme 48 modules) separated cleanly from policy. For group-of-machine protection they plan an electronic-cash market approach; for agent-from-host attacks they survey partial techniques (detection via audit trails, encrypted computation, trusted reference machines) since full prevention requires hardware support they do not assume.

Key Ideas

Four interrelated mobile-agent security problems.
Separation of enforcement mechanism from policy.
Multi-language support with a uniform C/C++ server library.
Cryptographic authentication + per-identity resource managers.
Open problem: protecting agents from malicious hosts without trusted hardware.

Connections

Conceptual Contribution

Claim: Mobile-agent security comprises four distinct but interrelated problems (protecting machine, protecting other agents, protecting agent from host, protecting group of machines); solving them requires layered mechanisms that cleanly separate enforcement from policy and span multiple execution languages.
Mechanism: Architectural description of D’Agents’ four-level stack (transport, server, interpreter, agents); PGP-based owner authentication; language-specific enforcement modules (Safe Tcl, Java security manager, Scheme 48) routed through a language-independent resource manager; planned e-cash market approach for aggregate-resource protection; survey of partial techniques (audit trails, encrypted computation) for the agent-from-host problem.
Concepts introduced/used: Mobile Agent, Four Security Problems, Mechanism vs Policy, Safe Tcl, Resource Manager Agent, PGP Authentication, Audit Trail, Encrypted Computation
Stance: engineering / survey
Relates to: Extends the earlier Agent Tcl Flexible Secure Mobile Agents with a mature security story; shares threat concerns with AI Agents Under Threat and Distributed Security; policy/mechanism separation echoes the sandboxing principles of Extensible Distributed Coordination and Agents Secure Interaction in Data Driven Languages.

Tags

Agent Tcl Flexible Secure Mobile Agents

Agent Tcl: A Flexible and Secure Mobile-Agent System

Reference: Robert S. Gray (1996). Proceedings of the 1996 USENIX Tcl/Tk Workshop, pp. 9-23. Source file: gray-security.pdf. URL

Summary

Gray introduces Agent Tcl, a mobile-agent system built on the Tcl scripting language plus Safe Tcl that supports migration with a single agent_jump instruction, transparent inter-agent communication, and pluggable transport mechanisms. The paper argues that Tcl’s simplicity and ease of embedding make it more accessible than Telescript’s object-oriented language while the Safe Tcl extension provides the sandboxing needed for secure execution — a better balance than the ARA, Tacoma, or SodaBot alternatives.

The architecture has four layers (transport, server, interpreter, agents) and supports PGP-signed agents, resource-manager-based authorization, direct-connection and message-passing communication, and a flat namespace of named agents. Gray details how the Tcl core was modified to capture complete interpreter state (stack, procedure frames, variables) for transparent migration at arbitrary points, and outlines a plan to add Java and Scheme as additional agent languages.

Key Ideas

Single-instruction migration (agent_jump) that transparently captures/restores state.
Safe Tcl for sandboxed execution with policy decoupled from mechanism.
Layered architecture supporting multiple languages and transports.
Security approach: PGP-signed code + resource managers + Safe Tcl.
Explicit interpreter stack rewrite to enable mid-execution migration.

Connections

Conceptual Contribution

Claim: A mobile-agent system can be both simple and secure by building on an interpreted scripting language (Tcl) augmented with Safe Tcl sandboxing, exposing migration as a single instruction that transparently captures/restores complete interpreter state.
Mechanism: Modifies the Tcl core to use an explicit command stack (replacing recursive Tcl_Eval) so full execution state is capturable; primitives agent_begin/submit/jump/send/receive/meet/accept provide uniform mobility and messaging; security via PGP-signed agents + per-identity resource managers + Safe Tcl trusted/untrusted dual interpreters with link substitution.
Concepts introduced/used: Mobile Agent, agent_jump, State Capture, Safe Tcl, Sandboxing, Explicit Command Stack, Flat Namespace, Resource Managers
Stance: engineering
Relates to: Precursor to DAgents Security Book Chapter which formalises the security model; contemporary alternative to Telescript/ARA/Tacoma (discussed in the D’Agents chapter); shares interpreter-level security philosophy with Agents Secure Interaction in Data Driven Languages.

Tags

Lowe Attack

Gavin Lowe’s (1995) man-in-the-middle attack on the Needham-Schroeder public-key authentication protocol, discovered by formal model-checking with FDR (Lowe 1996, TACAS). A dishonest principal I who has been engaged by an honest A can interpose himself between A and an honest B: the second message of the protocol — {N_A, N_B}_pubA — does not include B’s identity, allowing I to forward B’s response to A and then impersonate A to B. The fix is to include B in the second message. The attack is the canonical worked example for why informal correctness arguments in cryptographic-protocol design are insufficient.

In this vault

Needham-Schroeder Protocol

The 1978 authentication protocol family of Needham & Schroeder. Symmetric-key version uses a trusted authentication server holding long-term keys for all principals; basis of Kerberos. Public-key version uses three messages and two nonces between the principals directly. Famous as the canonical case-study for cryptographic-protocol verification: Lowe (1995/1996) found a man-in-the-middle attack on the public-key version using FDR model-checking, 17 years after publication, with a one-line fix (include responder’s identity in message 2). The story launched the modern protocol-verification field.

In this vault

Using Encryption for Authentication

Using Encryption for Authentication in Large Networks of Computers

Reference: Needham, R. M. & Schroeder, M. D. (1978). Using Encryption for Authentication in Large Networks of Computers. Communications of the ACM, 21(12), pp. 993–999. (With critical follow-up: Lowe, G. (1995). An Attack on the Needham–Schroeder Public-Key Authentication Protocol. Information Processing Letters 56(3), pp. 131–133, and Lowe (1996) Breaking and Fixing the Needham–Schroeder Public-Key Protocol Using FDR, TACAS ’96.) ACM DOI · Open access PDF (UT Austin) · Lowe attack (1995) DOI

Summary

Needham and Schroeder describe two foundational authentication protocols for large untrusted networks: a symmetric-key protocol relying on a trusted authentication server (which became the basis of Kerberos), and a public-key protocol that establishes mutual authentication and a shared session-secret between two principals using only public-key encryption. The symmetric protocol uses nonces to prevent replay and a server S that knows long-term keys for every principal; messages 1–3 obtain a fresh session key K_AB from S, message 4 challenges B with a nonce, message 5 returns the nonce decremented as proof of session-key possession. The public-key protocol is shorter — three messages exchanging two nonces under the partners’ public keys, with mutual authentication established by demonstrating the ability to decrypt and return the partner’s nonce. The paper became a touchstone of the cryptographic-protocol literature, both for what it got right (the use of nonces, the trusted-third-party authentication server, the layered structure of session establishment) and — famously — for what it got wrong. In 1995 Gavin Lowe found that the public-key protocol is vulnerable to a man-in-the-middle attack: a dishonest principal I can interpose himself between A and B, convincing B that A initiated a session with him when in fact A initiated a session with I. The flaw is invisible in the original informal argument; Lowe found it by formal model-checking with FDR, and the fix (include B’s identity in the second message) is a one-line change. The Needham-Schroeder–Lowe story became the canonical case-study for why formal protocol verification matters: a protocol that “looked correct” for 17 years and was widely cited contained a fundamental flaw that was systematically discovered the moment a formal tool was applied.

Key Ideas

Trusted authentication server (Kerberos lineage): in the symmetric-key protocol, an online server S shares a long-term key with every principal and brokers session-key establishment between any pair. This pattern became the architectural foundation of Kerberos and (with adjustments) of every realistic enterprise SSO system.
Nonces for freshness: each principal includes a nonce in their request so that replay of an old session-key message can be detected. The use of nonces is correct; their interpretation in BAN-style analysis is more subtle than the original informal argument suggested.
Public-key symmetric-style authentication: the public-key protocol shows authentication can be done without an online server given only certificates of long-term public keys — three messages, two nonces, mutual authentication.
The Lowe attack: in the original public-key protocol, message 2 from B to A returns {N_A, N_B}_pubA (A’s nonce together with B’s nonce, encrypted with A’s public key). If A is talking to a dishonest I, then I can re-encrypt and forward to B, who responds to I thinking he is responding to A — and I can pose as A to B for the duration of the session. The attack is a strict man-in-the-middle: A and B reach inconsistent beliefs about who they are talking to.
The Lowe fix: include B’s identity in message 2 — {N_A, N_B, B}_pubA — so that A can verify the message was intended for him from B specifically and the substitution attack is detected.
Methodological lesson: informal correctness arguments — even by careful authors over careful protocols — are unreliable for cryptographic protocols. Formal verification (BAN Logic, Spi Calculus, ProVerif, FDR) is necessary, not optional.

Connections

Conceptual Contribution

Claim: Cryptographic authentication in large networks can be built from a small set of primitives — long-term keys, nonces for freshness, a trusted third party (or public-key infrastructure) — combined into protocols of three to five messages. (And the now-canonical second claim, supplied by Lowe 1995/1996: even careful informal arguments for such protocols cannot be trusted; formal verification is required.)
Mechanism: Two protocol designs — symmetric-key with online server, public-key with PKI — using nonces for freshness and explicit role identifiers. Lowe’s contribution: model-checking the public-key protocol with FDR, finding the man-in-the-middle attack, and supplying the one-message fix.
Concepts introduced/used: Needham-Schroeder Protocol, Nonce, Replay Attack, Trusted Third Party, Public-Key Authentication, Lowe Attack, Man-in-the-Middle Attack.
Stance: foundational protocol design + canonical worked example for protocol verification.
Relates to: Direct ancestor of Kerberos and of every enterprise authentication-and-key-distribution system. Provides the worked example that motivates BAN Logic (Burrows, Abadi & Needham 1990 — Needham himself); the original protocol’s analysis under BAN already revealed weaknesses missed in the 1978 informal argument. Lowe’s 1995/96 attack and FDR analysis launched the formal-methods-for-protocols programme that produced the Spi Calculus (Abadi & Gordon 1997) and the symbolic provers ProVerif / Tamarin. The Lowe attack is structurally a parser-differential attack at the protocol level — A and B parse the protocol-state differently, with I exploiting the difference — directly analogous to the PKI Layer Cake - Kaminsky Patterson Sassaman attack on certificate parsing in PKIs. Within the agent-communication literature, NS is the canonical example proving that informal speech-act-based protocol correctness arguments — including most ACL conformance arguments — are insufficient: a KQML or FIPA-ACL interaction protocol with the same structural flaw would have the same vulnerability, and ACL conformance methodologies need the same kind of formal underpinning.

Tags

#crypto-protocols #authentication #needham #schroeder #lowe #replay-attack #security #foundations

Pi-Calculus

A process calculus introduced by Milner, Parrow & Walker (1992) in which the names communicated between processes are themselves channels. Combines the parallel-composition and synchronisation primitives of CCS with name-passing, giving a single primitive that subsumes communication and dynamic network reconfiguration. The standard substrate for Session Types, Choreographic Programming, and modern formal accounts of Mobility and Concurrency. Comes in monadic, polyadic, asynchronous, higher-order, and applied (with cryptography) variants.

In this vault

A Calculus of Mobile Processes — Milner, Parrow & Walker 1992 (original)
A Calculus of Communicating Systems — Milner 1980 (predecessor)
Communicating Sequential Processes — Hoare 1978 (sibling)
Mobile Ambients — Cardelli & Gordon 1998 (locations-first sibling)
Spi Calculus — Abadi & Gordon 1997 (cryptographic extension)
Join Calculus — Fournet & Gonthier 1996 (asynchronous reformulation)
Sjoin Calculus
Session Types
Multiparty Asynchronous Session Types
Structured Communication-Centred Programming for Web Services
Choreographic Programming
Pact - A Choreographic Language for Agentic Ecosystems
Name-Passing
Scope Extrusion
Bisimulation
Mobility
Process Calculi

Spi Calculus

Abadi & Gordon’s (1997) extension of the Pi-Calculus with cryptographic primitives — encryption, decryption, hashing, pairing, name-equality. Security properties (authentication, secrecy) are formalised as process equivalences: a protocol is secure iff no spi-calculus context can distinguish it from an idealised specification. The most general attacker is just an arbitrary spi process. Foundation under ProVerif / Tamarin and the applied π-calculus (Abadi & Fournet 2001).

In this vault

BAN Logic

The belief logic of Burrows, Abadi & Needham (1990) for analysing cryptographic authentication protocols. A small modal language with operators P believes X, P sees X, P said X, P controls X, fresh(X), P shares K with Q. Inference rules (message-meaning, nonce-verification, jurisdiction) propagate beliefs as messages are received and decrypted. Verification proceeds by idealising the protocol, stating initial beliefs, and deriving the goal beliefs (typically: authenticated session-key agreement). The first widely-adopted formal method for protocol analysis; superseded by Spi Calculus / ProVerif for rigorous use, but still pedagogically dominant.

In this vault

A Logic of Authentication

Reference: Burrows, M., Abadi, M. & Needham, R. (1990). A Logic of Authentication. ACM Transactions on Computer Systems, 8(1), pp. 18–36. (Earlier DEC SRC Research Report 39, 1989.) ACM DOI · Open access PDF (Stanford)

Summary

Burrows, Abadi and Needham introduce BAN logic — a belief logic for reasoning about the authentication properties of cryptographic protocols. The setting is the symbolic Dolev-Yao world: principals communicate by exchanging cryptographic messages over an untrusted network. BAN provides a small modal language whose primary modality is P believes X (“principal P believes X”) together with auxiliary operators (P sees X, P said X, P controls X, fresh(X), P has K, K is shared between P and Q). Its inference rules (the message-meaning rule, nonce-verification rule, jurisdiction rule, freshness rule, etc.) capture how beliefs propagate as messages are received and decrypted — for instance, if P believes K is a key shared with Q and P sees {X}_K and P believes X is fresh, then P may conclude that Q recently sent X. Verification proceeds by idealising the protocol (replacing each message by the abstract belief-statement it is intended to convey), making explicit assumptions about initial beliefs, and then deriving the goal beliefs (typically, that the principals share a fresh authenticated session key). The paper analyses Kerberos, the original Needham-Schroeder protocol, the Andrew Secure RPC handshake, and several others — finding errors and clarifying intended semantics. BAN was a watershed: the first widely-adopted formal method for authentication-protocol analysis. Its limitations (no explicit attacker model, the idealisation step is informal, soundness is debatable for unintended uses) drove the development of more rigorous frameworks — notably the Spi Calculus (process-calculus equivalence-based) and the symbolic provers ProVerif / Tamarin — but the belief-logic style remains in widespread teaching use as the most intuitive entry to protocol verification.

Key Ideas

Belief modalities: P |≡ X (P believes X), P ⊲ X (P sees / receives X), P |~ X (P once said X), P ⇒ X (P has jurisdiction over X — i.e. is an authority on it).
Cryptographic primitives appear in formulas: {X}_K (X encrypted with K), <X>_Y (X with secret Y), (X, Y) (concatenation), with associated extraction rules.
Inference rules as belief-derivation: e.g. message-meaning — if P believes K is shared with Q and sees {X}_K, then P believes Q once said X. Nonce-verification — if P believes Q once said X and P believes X is fresh, then P believes Q currently believes X. Jurisdiction — if P believes Q controls X and P believes Q believes X, then P believes X.
Idealisation: each protocol message is rewritten into an abstract form that makes its intended belief-meaning explicit (typically, the protocol designer has to do this — and the soundness of the analysis depends on the idealisation being faithful).
Goal beliefs: an authentication protocol is correct (in BAN) iff the participants reach the intended mutual beliefs about a fresh session key (P |≡ P ↔K Q, Q |≡ P ↔K Q, often with belief-about-belief: P |≡ Q |≡ P ↔K Q).
Found bugs in real protocols: BAN-style analysis of Needham-Schroeder shared-key protocol revealed that one party could not prove freshness of a session key — the bug Lowe later exploited symbolically.

Connections

Conceptual Contribution

Claim: Authentication properties of cryptographic protocols can be derived in a small modal belief logic whose inference rules capture how beliefs propagate when messages are received and decrypted; verifying a protocol becomes (i) idealising it as a sequence of abstract belief-statements, (ii) stating initial beliefs, and (iii) deriving the goal beliefs. This is rigorous enough to find real bugs in deployed protocols.
Mechanism: Modal language with believes / sees / said / controls / fresh / shares-key operators; ~20 inference rules covering message-meaning, nonce-verification, jurisdiction, freshness, and decomposition; idealisation step from concrete protocol messages to belief-statements; standard goal beliefs for authentication and key establishment.
Concepts introduced/used: BAN Logic, Belief Modality, Idealisation (of protocols), Nonce-Verification Rule, Jurisdiction Rule, Crypto Protocol Verification, Mentalistic Semantics (in the cryptographic setting).
Stance: foundational technical paper — the first widely-adopted formal method for cryptographic-protocol analysis.
Relates to: Conceptually parallel to the mentalistic-semantics family in the ACL literature (KQML, FIPA-ACL) — both treat communication as belief-update under explicit modal operators. BAN is exactly what one gets if one specialises mentalistic ACL semantics to cryptographic-protocol exchanges. The critique that struck mentalistic ACLs (Singh’s argument that beliefs cannot be observed by third parties) hits BAN in the same way: the idealisation step is informal, and “soundness” presupposes the very mental-state assumptions one cannot verify externally. The Spi Calculus (Abadi & Gordon 1997) is BAN’s process-calculus counterpoint — equivalence-based rather than belief-based, with the attacker built in as an arbitrary context. The Lowe attack on Needham-Schroeder, derivable from a careful BAN analysis but missed by the original 1978 informal argument, is the canonical worked example demonstrating why formal protocol verification matters and why even rigorous methods need more rigorous successors. BAN’s belief modalities also share semantic ground with Halpern & Moses 1990 — both apply epistemic logic to distributed/multi-agent systems, with BAN specialising to authentication and Halpern–Moses staying general.

Tags

#crypto-protocol-verification #ban-logic #belief-logic #burrows #abadi #needham #security #foundations

Programming Erlang Second Edition

Programming Erlang: Software for a Concurrent World (Second Edition)

Reference: Armstrong, J. (2013). The Pragmatic Bookshelf. Source file: cbcl-ref/programming-erlang-2nd-edition.pdf. URL

Summary

Joe Armstrong’s second-edition textbook introduces Erlang as a language and runtime for building highly concurrent, distributed, and fault-tolerant systems. Part I motivates concurrency and tours the shell, modules, and compilation. Part II teaches sequential Erlang: atoms, tuples, lists, pattern matching, funs, records/maps, error handling with try/catch, binaries and the bit syntax, and the type system with Dialyzer.

Part III covers the concurrency primitives (spawn/send/receive), error handling in concurrent programs (links, monitors, supervised fault-tolerance), and distributed programming over Erlang nodes. Part IV covers libraries and frameworks (ports for C interfacing, files, sockets, web/WebSocket applications, ETS/DETS and Mnesia databases, and profiling/debugging/tracing). The book is widely cited as a canonical introduction to the Actor model and the “let it crash” philosophy that informs modern reactive and distributed-agent systems.

Key Ideas

Actor-model concurrency: processes + asynchronous message passing.
“Let it crash” + supervision trees for fault tolerance.
Pattern matching as pervasive control structure.
Distributed programming built on the same primitives as local.
Mnesia, ETS/DETS for in-memory and persistent storage.

Connections

Conceptual Contribution

Claim: Concurrent, distributed and fault-tolerant software is simpler and more reliable when built on isolated processes that share nothing and communicate only by asynchronous messages, with failures handled by supervision rather than defensive programming (“let it crash”).
Mechanism: Armstrong teaches the Erlang trinity of spawn / send / receive, reinforces isolation via immutability and pattern matching, and then layers links, monitors and supervisor trees for systemic recovery. Distribution uses the same primitives as local concurrency, so topology becomes deployment-time. Supporting libraries (ports for C, sockets, ETS/DETS, Mnesia, tracing/profiling, web/WebSocket) show how the model scales to realistic systems.
Concepts introduced/used: Actor Model, Let It Crash, Supervision Tree, Erlang Process, Pattern Matching, Link and Monitor, Mnesia, ETS-DETS, Bit Syntax, OTP
Stance: engineering
Relates to: The practical counterpart to the fault-tolerance philosophy of Theory of Self-Reproducing Automata and the architectural dependability of Architectural Patterns for Dependable Software Systems - SOL; its message-passing primitives underpin agent frameworks surveyed in Intelligent Agents Theory and Practice and mesh with the calculus-level treatment in Secure Communications Processing for Distributed Languages.

Tags

The Spoofax Language Workbench

The Spoofax Language Workbench: Rules for Declarative Specification of Languages and IDEs

Reference: Kats, L. C. L., Visser, E. (2010). Proc. OOPSLA 2010, ACM SIGPLAN Notices. Source file: The_Spoofax_Language_Workbench_Rules_for_Declarati.pdf. URL

Summary

Spoofax is an Eclipse-based language workbench that lets developers define a DSL’s syntax, semantics, and full IDE support (syntax highlighting, content completion, reference resolution, refactoring, error marking, code generation) entirely via concise declarative specifications. Syntax is expressed in SDF with permissive error-recovery grammars; transformations, name analysis, and code generation are written in Stratego; editor services are declared in rule-based service descriptors.

The architecture separates language-parametric infrastructure from language-specific definitions and supports agile development: language definitions can be dynamically loaded into the same Eclipse instance and tested side-by-side. The paper describes component dependencies (grammar-driven presentation services, semantic services derived from name analysis) and contrasts Spoofax with EMFText, MPS, Xtext, and the Synthesizer Generator. The result is a coherent, concise toolchain for agile DSL + IDE development.

Key Ideas

Single declarative spec drives both compiler and IDE services.
SDF grammars + Stratego rewrites as the semantic base.
Permissive grammars for error recovery.
Editor service descriptors separate “which” from “what”.
Dynamic loading enables agile language development.

Connections

Conceptual Contribution

Claim: A language and its IDE can be specified together, declaratively, from a single set of high-level rules — removing the gulf between compiler front-ends and interactive tooling that has historically doomed DSLs to poor editor support.
Mechanism: Spoofax composes SDF (scannerless generalized-LR grammars, with permissive error-recovery productions), Stratego (rewrite-based transformations for name analysis, type checking, code generation), and editor-service descriptors that declare syntax highlighting, reference resolution, completion, outline, and refactoring. The Eclipse plug-in hot-loads new language definitions, enabling round-trip agile development; grammar-driven services are separated from semantics-driven services to manage dependencies.
Concepts introduced/used: Language Workbench, SDF, Stratego, Editor Service Descriptor, Permissive Grammar, Declarative Specification, Meta-Programming, DSL
Stance: engineering
Relates to: A concrete instance of the “whole-language” tooling vision behind A Modular Approach to Metatheoretic Reasoning for Extensible Languages and Extensibility in Programming Language Design - Standish; the rule-based services resonate with Creating Languages in Racket, and the formal-analysis possibilities connect to the dependability specification of Architectural Patterns for Dependable Software Systems - SOL.

Tags

Creating Languages in Racket

Reference: Matthew Flatt (2012). Communications of the ACM, Vol. 55, No. 1. Source file: 2063176.2063195.pdf. URL

Summary

Practitioner-oriented introduction to Racket’s support for language-oriented programming: building domain-specific languages as a natural extension of ordinary programming. Flatt develops a text-adventure game incrementally, starting from Racket’s core, adding pattern-matching macros (define-syntax-rule) for define-place, define-thing, define-verb, then packaging these extensions into a module language (#lang txtadv) with its own non-parenthesised reader syntax and IDE (DrRacket) support.

The article demonstrates the full spectrum from simple syntactic abstraction via macros up through module languages that replace the default reader, showing how Racket smooths the path from library to full DSL.

Key Ideas

Language-oriented programming as a practical paradigm
define-syntax-rule and syntax-case macros for pattern-based extension
Module languages (#lang ...) package extensions as first-class languages
Static checks can be implemented via macro-level type tagging
DrRacket provides IDE integration for custom languages

Connections

Conceptual Contribution

Claim: Language-oriented programming — building a small DSL exactly fitted to a task — should be cheap and incremental, not a heavyweight “build a compiler” affair; Racket’s macro system and module-language machinery make this the normal way to program.
Mechanism: Walk through a text-adventure game implementation that evolves from plain-Racket library → syntactic abstractions (define-syntax-rule for define-place, define-thing) → a full #lang txtadv module language with custom reader, static checks via compile-time elaboration, and replaceable surface syntax; show each step as a small syntactic or module addition rather than a rewrite.
Concepts introduced/used: Language-oriented Programming, Racket Macros, Module Languages, Syntactic Abstraction, DSLs, Domain-Specific Languages, Language Workbenches, Hygienic Macros, Macros as Language Extension
Stance: engineering / tutorial
Relates to: Modern realisation of the paraphrase-extension ideal diagnosed in Extensibility in Programming Language Design - Standish and evangelised in The Extensible Language - Graham. Provides the practice for which A Modular Approach to Metatheoretic Reasoning for Extensible Languages supplies a metatheoretic backbone.

Tags

A Modular Approach to Metatheoretic Reasoning for Extensible Languages

Reference: Dawn Michaelson, Gopalan Nadathur, and Eric Van Wyk (2023). arXiv:2312.14374v1. Source file: 2312.14374v1.pdf. URL

Summary

Addresses the problem of proving metatheoretic properties (e.g. type preservation, information-flow non-interference) for languages composed from a host and a library of independently developed extensions. The authors propose decomposing proofs around language fragments and introducing a priori constraints — notably projection constraints that let extensions describe how their constructs behave at a distance — so that complete soundness proofs for any composed language can be automatically stitched together from per-extension partial proofs.

The framework distinguishes foundational properties (known to the host, like type preservation) from auxiliary properties (introduced by a later extension, like a security analysis). The paper develops the machinery in a relational logic with rule-based specifications and motivates the Extensibella and Sterling tool systems.

Key Ideas

Modular metatheory: per-extension partial proofs composed automatically
Projection constraints let extensions reason about unknown other extensions at a distance
Foundational vs auxiliary properties require different modularity treatments
Relational rule-based specifications with fixed-point semantics
Connects language-workbench practice to formal metatheory

Connections

Conceptual Contribution

Claim: Metatheoretic properties (type preservation, information-flow soundness, etc.) of an extensible language — built by composing a host language with a library of independently-developed extensions — can be proven modularly: each extension supplies a partial proof, and the host + projection-constraints framework guarantees these partial proofs compose soundly without a closed-world assumption.
Mechanism: Distinguish foundational properties (known at host-language design time; each extension contributes a local proof obligation) from auxiliary properties (introduced later by some extension; proofs must use projection relations to reason about other extensions’ constructs “at a distance”). Formalise the framework via a rule-based logic with least-fixed-point semantics; sketch realisation in the Extensibella and Sterling systems.
Concepts introduced/used: Metatheoretic Reasoning, Modular Proofs, Projection Relations, Foundational vs Auxiliary Properties, Language Workbenches, Type Preservation, Attribute Grammars, Closed World Assumption, Fixpoint Semantics, Relational Logic
Stance: formal / programming-language theory
Relates to: Supplies the metatheoretic rigour that Creating Languages in Racket and The Extensible Language - Graham implicitly assume but don’t prove. Directly addresses the theoretical obstacles Standish flagged in Extensibility in Programming Language Design - Standish for orthophrase-style extensions. The modular-composition instinct parallels Event-B refinement in Formalise Blockchain Interoperability Patterns.

Tags

Extensibility in Programming Language Design - Standish

Extensibility in Programming Language Design

Reference: Thomas A. Standish (1975). National Computer Conference 1975 (AFIPS). Source file: 1499949.1500003.pdf. URL

Summary

A retrospective on the 1960s-70s “extensible languages” movement. Standish catalogues extension techniques (paraphrase, orthophrase, metaphrase), reviews what the early community hoped for — a universal base language that any user could tailor with modest effort — and explains why those hopes were only partly realised. He concludes that extensibility relates to high-level languages the way macros relate to assembly: useful for suppressing low-level detail and masking irritating features, but not the programming revolution once promised.

The paper is an early, honest assessment of why language extension is harder than anticipated, introducing vocabulary still used today.

Key Ideas

Paraphrase: defining new forms via existing ones (macros, procedures)
Orthophrase: adding orthogonal features that cannot be paraphrased
Metaphrase: altering interpretation rules (scoping, evaluation)
Early euphoria vs realistic assessment of labour/skill costs
27 extensible languages proposed by 55 people by 1975

Connections

Conceptual Contribution

Claim: The 1960s-70s dream of universal extensible languages largely failed because extension techniques divide into qualitatively different kinds with very different labor costs; only the cheapest (paraphrase, macros) proved practically useful.
Mechanism: Taxonomy of extension techniques — paraphrase (define new forms in terms of existing ones: macros, procedures, syntax macros, data/operator definitions), orthophrase (add genuinely new features outside the base language’s span, e.g. I/O primitives), and metaphrase (alter interpretation rules: scoping, evaluation order). Argues orthophrase/metaphrase require near-compiler-writer expertise and rarely pay off.
Concepts introduced/used: Paraphrase, Orthophrase, Metaphrase, Macros as Language Extension, Language Extensibility Taxonomy, Extensible Languages Movement, Domain-Specific Languages
Stance: retrospective-critique / taxonomic
Relates to: Direct intellectual ancestor of The Extensible Language - Graham and Creating Languages in Racket, both of which represent the paraphrase/macro wing that Standish judged successful. A Modular Approach to Metatheoretic Reasoning for Extensible Languages tackles the metatheoretic difficulties Standish foresaw for orthophrase extensions.

Tags

The Extensible Language - Graham

The Extensible Language

Reference: Paul Graham (1993). On Lisp (Chapter 1). Source file: 01theExtensibleLanguage.pdf. URL

Summary

Opening chapter of Graham’s On Lisp that argues Lisp’s defining quality is its extensibility: the language can be molded into a dialect suited to the program being written. Graham distinguishes top-down from bottom-up design and claims Lisp programmers customarily do both — building the language up toward the problem while writing the program down toward it.

The chapter introduces macros, embedded languages, and the idea that a mature Lisp program looks “as if the language had been designed for it.” It argues that software extensibility (where users extend a program in its own implementation language) is a more honest outgrowth of bottom-up programming than traditional black-box designs.

Key Ideas

Bottom-up design: grow the language toward the problem via new operators and macros
Lisp programs are data — macros are programs that write programs
Embedded languages as a natural idiom; Common Lisp includes several (e.g. CLOS)
Extensible software as a paradigm; language and program co-evolve

Connections

Conceptual Contribution

Claim: A language’s power lies not in a fixed feature set but in its capacity to be grown, by its users, into a problem-specific dialect — Lisp’s distinguishing virtue is that it makes this routine.
Mechanism: Code-as-data (s-expressions) + macros + first-class functions enable users to add operators indistinguishable from built-ins; bottom-up design then layers embedded languages on top of the base.
Concepts introduced/used: Bottom-up Programming, Macros as Language Extension, Embedded Languages, Domain-Specific Languages, Language Workbenches, Code as Data, S-expressions, Lisp
Stance: engineering / manifesto
Relates to: Shares a through-line with Extensibility in Programming Language Design - Standish (paraphrase/orthophrase/metaphrase taxonomy), Creating Languages in Racket (macro-based language-oriented programming), and A Modular Approach to Metatheoretic Reasoning for Extensible Languages (formal reasoning about user-added language fragments). The same “grow the language toward the problem” instinct reappears in agent-communication as Agora’s emergent Protocol Documents in A Scalable Communication Protocol for Networks of LLMs.

Tags

Ontology Change Classification and Survey

Ontology Change: Classification and Survey

Reference: Flouris, Manakanatas, Kondylakis, Plexousakis, Antoniou (2008). The Knowledge Engineering Review, Cambridge University Press. Source file: Ontology_Change_Classification_and_Survey.pdf. URL

Summary

This survey tackles the terminological confusion surrounding ontology change in the Semantic Web era. The authors argue that many overlapping terms — ontology evolution, versioning, merging, mapping, matching, articulation, translation, debugging, integration, morphism — are used inconsistently across the literature, creating a major bottleneck for research. They propose a unifying terminology and taxonomy, fixing precise definitions and identifying the boundaries between ten subfields of ontology change plus ontology alignment.

The paper organizes these subfields into four groups: heterogeneity resolution (mapping/matching/articulation/morphism/translation), modification (evolution, debugging/diagnosis/repair), fusion (integration, merging), and versioning. Each field is characterized by its purpose, inputs, outputs, and properties, and the authors review representative algorithms and systems, including a detailed classification of matching approaches (instance vs. schema, element vs. structure, language vs. constraint, matching cardinality, auxiliary information).

Key Ideas

Ontology change is the generic process of adapting an ontology to a need for change.
Heterogeneity resolution is a prerequisite for any successful ontology change.
Formal pair <S, A> defines an ontology by signature and axioms.
Ten interlinked subfields are identified and disambiguated.
Ontology evolution is closely tied to belief revision.

Connections

Conceptual Contribution

Claim: Research on ontology change is fragmented by inconsistent terminology; a precise, unified taxonomy is needed before the field’s problems can be compared, composed, or solved.
Mechanism: The authors define an ontology formally as a signature–axiom pair <S,A>, then enumerate ten subfields (mapping, matching, morphism, articulation, translation, evolution, debugging, versioning, integration, merging) and characterise each by inputs/outputs/properties. Representative algorithms and systems are then slotted into the taxonomy, with matching approaches classified by dimension (schema vs. instance, element vs. structure, cardinality, auxiliary info).
Concepts introduced/used: Ontology Change, Ontology Evolution, Ontology Mapping, Ontology Merging, Ontology Alignment, Belief Revision, Semantic Web, Heterogeneity Resolution
Stance: survey
Relates to: Provides the vocabulary implicitly assumed by ACL work on shared ontologies (The State of the Art in Agent Communication Languages, Trends in Agent Communication Language) and complements the handbook-level treatment in Handbook On Ontologies. Its belief-revision framing links to epistemic semantics used in Agent-Oriented Programming.

Tags

Handbook On Ontologies

Handbook on Ontologies

Reference: Staab & Studer, eds. (2004). International Handbooks on Information Systems, Springer. Source file: CAP_LIB_05.pdf. URL

Summary

The Handbook on Ontologies provides a comprehensive reference on ontology research and practice. It is organized into four parts: (A) Ontology Representation and Reasoning (Description Logics, Frame Logic, RDF(S), OWL, ontology algebra); (B) Ontology Engineering (methodologies, large case studies, OntoClean, ontology learning, knowledge patterns, lexicons); (C) Ontology Infrastructure (management environments, problem-solving methods, multi-agent interaction, merging/mapping, browsing, visualization); and (D) Ontology Applications (knowledge management, eCommerce, semantic portals, hypermedia, enterprise integration, bioinformatics).

The introduction positions ontologies as formal, explicit specifications of shared conceptualizations and traces their rise from knowledge-based systems through the Semantic Web into mainstream information systems.

Key Ideas

Standard definition: ontology = formal, explicit specification of shared conceptualization.
Four-part organization: representation, engineering, infrastructure, applications.
Description Logics and Frame Logic as main representation paradigms.
OWL, RDF(S), and ontology algebra as Semantic Web foundations.
Multi-agent systems rely on ontologies for communication semantics.

Connections

Conceptual Contribution

Claim: Ontologies - formal, explicit specifications of shared conceptualisations - are the unifying infrastructure behind knowledge-based systems, the Semantic Web, and multi-agent communication semantics.
Mechanism: Four-part reference structure covering representation/reasoning (DL, F-Logic, RDF(S), OWL, ontology algebra), engineering (OntoClean, ontology learning, patterns), infrastructure (management, merging, MAS interaction), and applications (KM, eCommerce, bioinformatics).
Concepts introduced/used: Ontologies, Description Logics, OWL, RDF, Frame Logic, Ontology Engineering, Semantic Web, Multi-Agent Systems, Agent Communication Languages
Stance: foundational / survey
Relates to: Supplies the representational substrate assumed by A Common Ontology Of ACLs, Semantic Description For Agent Design Patterns, and the content-layer opacity of KQML Language And Protocol / FIPA-ACL.

Tags

Ontolingua Portable Ontology Specifications

A Translation Approach to Portable Ontology Specifications

Reference: Thomas R. Gruber (1993). Knowledge Acquisition, 5(2):199-220 (KSL Technical Report KSL-92-71). Source file: ontolingua-kaj-1993.pdf. URL

Summary

Gruber’s landmark paper defines an ontology as “an explicit specification of a conceptualization” — a formal vocabulary of classes, relations, functions, and axioms that captures the intended meaning of terms shared among knowledge-based systems. He addresses the portability problem: ontologies need to be reused across applications built in different representation languages (frame-based, description-logic, relational, Prolog), which would otherwise each need bespoke versions.

The solution is Ontolingua, a system that specifies ontologies in a standard declarative form (predicate calculus extended with KIF and frame-ontology idioms) and translates them into the forms required by specific target representation systems. The approach accommodates stylistic differences across representations while preserving declarative content, and handles translation from an expressive source into restricted targets. The paper articulates criteria for good ontology design (clarity, coherence, extendibility, minimal encoding bias, minimal ontological commitment) that still guide knowledge-engineering practice today.

Key Ideas

Ontology = explicit specification of a conceptualization.
Ontological commitments as agreements about shared vocabulary.
Translation approach: one source language → many target representations.
Ontolingua built atop KIF and a frame ontology.
Design criteria: clarity, coherence, extendibility, minimal encoding bias.

Connections

Conceptual Contribution

Claim: Shared knowledge among heterogeneous AI systems requires explicit, portable specifications of conceptualisations — ontologies — that can be defined once in a neutral declarative form and mechanically translated into many target representation systems while preserving declarative content.
Mechanism: Defines “ontology” as explicit specification of a conceptualisation; introduces ontological commitments as vocabulary-sharing agreements at the knowledge level (Newell); implements Ontolingua in KIF (Lisp-like predicate calculus with equality) with a Frame Ontology capturing class/relation/function/axiom idioms; provides translators to LOOM, Epikit, Express, and pure KIF. Proposes design criteria: clarity, coherence, extendibility, minimal encoding bias, minimal ontological commitment.
Concepts introduced/used: Ontology, Conceptualization, Ontological Commitment, KIF, Frame Ontology, Ontolingua, Knowledge-Level Specification, Translation Approach, Ontology Design Criteria
Stance: foundational / engineering
Relates to: Solves the content-language side of the problem that KQML Overview splits into content/message/communication layers; cited by virtually all agent-communication work needing shared vocabulary including FIPA-ACL, A Common Ontology Of ACLs, and Handbook On Ontologies; design criteria still guide modern ontology engineering.

Tags

On the Pitfalls of Measuring Emergent Communication

Reference: Lowe, Foerster, Boureau, Pineau, Dauphin (2019). AAMAS 2019 (Proc. 18th Intl. Conf. on Autonomous Agents and Multiagent Systems). Source file: p693.pdf. URL

Summary

This paper critically examines metrics used to detect and measure emergent communication in multi-agent reinforcement learning. The authors show that commonly used indicators — such as speaker consistency (SC), context independence (CI), mutual information between messages and actions, and message-entropy — can be misleading: agents trained with a communication channel that does not influence their behavior may still exhibit high values on these metrics, producing the illusion of communication.

To disentangle the phenomenon, they propose decomposing communication into positive signaling (messages carry information about a speaker’s observations) and positive listening (messages influence a listener’s subsequent actions). They introduce causal influence of communication (CIC), a causal-intervention-based metric measuring how an agent’s message changes another agent’s action distribution, and demonstrate its properties on matrix communication games (MCGs). They offer concrete recommendations for when each metric should be trusted.

Key Ideas

Speaker consistency can be positive even when no communication happens.
Separate positive signaling from positive listening.
Causal influence of communication (CIC) via interventions on messages.
Matrix Communication Games as a minimal testbed.
Entropy-based metrics are shape-dependent and deceptive.

Connections

Conceptual Contribution

Claim: Popular metrics for emergent communication in MARL cannot distinguish real communication from spurious correlations; communication must be analysed causally, decomposed into signalling and listening.
Mechanism: The authors construct Matrix Communication Games where a policy with a non-influential communication channel still scores high on speaker consistency, context independence, mutual information, and entropy-based measures. They then define positive signalling and positive listening as orthogonal properties, and introduce Causal Influence of Communication (CIC) as a do-calculus intervention that measures how replacing the sent message would change the listener’s action distribution.
Concepts introduced/used: Positive Signalling, Positive Listening, Causal Influence of Communication, Speaker Consistency, Context Independence, Matrix Communication Games, Emergent Communication
Stance: critique
Relates to: Sharpens the empirical agenda of Emergence of Grounded Compositional Language in Multi-Agent Populations and Emergent Communication; its causal framing complements the decision-theoretic message-value account in Towards Automating the Evolution of Linguistic Competence and offers a verifiability foothold missing from the mentalistic semantics critiqued by Agent Communication Languages - Rethinking the Principles.

Tags

Emergence of Grounded Compositional Language in Multi-Agent Populations

Reference: Igor Mordatch and Pieter Abbeel (2018). AAAI-18. Source file: 11492-13-15020-1-2-20201228.pdf. URL

Summary

Proposes a multi-agent environment and differentiable training procedure in which agents develop an abstract compositional communication protocol purely from the need to coordinate on non-linguistic goals (move-to-location, look-at, etc.) in a 2D world with landmarks. Agents emit streams of discrete symbols (Gumbel-Softmax relaxed) along with physical actions; symbols acquire stable, interpretable meanings corresponding to goal types, landmarks, and agent identities.

The emergent language exhibits syntactic ordering, vocabulary-size regularization via a Dirichlet-process-inspired penalty, and non-verbal strategies (pointing, guiding) when symbols are disabled. The paper is a foundational piece in the modern “emergent communication” literature.

Key Ideas

Communication emerges from cooperative multi-agent RL with shared reward
Gumbel-Softmax makes discrete symbol channels differentiable
Vocabulary-size penalty (DP-style) prevents symbol proliferation and encourages compositionality
Non-verbal channels (gaze, position) substitute when verbal is unavailable
Symbols ground to concepts: GOTO, color, landmark/agent identity

Connections

Conceptual Contribution

Claim: A basic compositional language with coherent vocabulary and rudimentary syntax can emerge from scratch among agents in a physically-grounded, cooperative multi-agent environment, driven purely by the need to coordinate on shared goals.
Mechanism: N agents with private goals share a continuous 2D environment and emit discrete symbol streams; policies are trained end-to-end with differentiable communication (Gumbel-Softmax), shared reward, plus a Dirichlet-process-inspired vocabulary-sparsity penalty and an auxiliary goal-prediction reward. Non-verbal strategies (pointing, gaze) emerge when symbolic channel is unavailable.
Concepts introduced/used: Emergent Communication, Grounded Compositional Language, Symbol Grounding Problem, Compositionality, Gumbel-Softmax, Multi-Agent Reinforcement Learning, Referential Games, Language Games, Non-verbal Communication, Vocabulary Size Penalty, Dirichlet Process
Stance: empirical / computational-simulation
Relates to: Companion to Multi-Agent Cooperation and the Emergence of Natural Language (also referential games but 2-player, image-based). Contrasts with the pre-designed KQML as an Agent Communication Language and FIPA-ACL approaches: here semantics emerge from task pressure rather than being stipulated. Resonates with the emergent-protocol behaviour Agora exhibits in A Scalable Communication Protocol for Networks of LLMs.

Tags

Multi-Agent Cooperation and the Emergence of Natural Language

Multi-Agent Cooperation and the Emergence of (Natural) Language

Reference: Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni (2017). ICLR 2017. Source file: 1612.07182v2.pdf. URL

Summary

Introduces a referential-game framework for studying emergent communication: a sender sees a target/distractor image pair and sends a single symbol from a fixed vocabulary; a receiver must identify the target using that symbol. The agents are blank-slate neural networks trained only by communication-success reward. The paper studies whether agents converge, whether the emergent symbols align with human-interpretable semantics, and how to nudge the system toward natural-language-compatible codes.

Two sender architectures (agnostic vs informed) are compared; the informed sender produces richer vocabulary usage. A supplementary supervised image-labelling objective is shown to ground agent symbols to human concepts, making them partially interpretable to crowd-workers.

Key Ideas

Referential games as minimal test-beds for emergent protocols
Informed (feature-aware) sender yields more human-like symbol usage
Symbol purity measured against conceptual (McRae) categories
Mixing self-play with supervised labelling grounds emergent codes to natural language
Foundational for later emergent-communication literature

Connections

Conceptual Contribution

Claim: Two neural-network agents playing a referential game (sender/receiver over image pairs) can develop a symbolic code from scratch; with architectural and supervisory nudges, that code can be made to align with human-interpretable object categories.
Mechanism: Lewis-style signalling game with REINFORCE training; contrast agnostic vs informed sender architectures; analyse symbol-to-category purity; then mix supervised image-labelling with self-play to ground emergent symbols in human vocabulary (AlphaGo-inspired). Crowdsourced evaluation shows humans can guess the correct image 68% of the time from emitted symbols.
Concepts introduced/used: Emergent Communication, Referential Games, Lewis Signalling Games, Language Games, Grounding in Human Language, Symbol Grounding Problem, Cheap Talk, Symbol-Category Purity, REINFORCE, Compositionality
Stance: empirical / deep-learning
Relates to: Companion/precursor to Emergence of Grounded Compositional Language in Multi-Agent Populations (physical grounding, >2 agents). Feeds the emergent-protocol thesis of A Scalable Communication Protocol for Networks of LLMs. Contrasts with stipulated-semantics ACLs (KQML as an Agent Communication Language, FIPA-ACL).

Tags

Language Games for Autonomous Robots

Reference: Steels, L. (2001). IEEE Intelligent Systems, Sept/Oct 2001. Source file: steels01languageGames.pdf. URL

Summary

Steels presents language games as a paradigm for creating grounded, open-ended dialogue between autonomous robots and humans. A language game is a scripted verbal interaction situated in a shared environment that simultaneously exercises perception, conceptualization, verbalization, interpretation, and action. By playing repeated games, agents integrate disparate AI components (vision, speech, planning, learning) into a coherent whole and bootstrap shared vocabulary and meaning without a central designer.

The paper details the guessing game as a canonical example: a speaker picks a topic, conceptualizes a distinguishing feature, verbalizes it, and the listener tries to identify the referent — feedback updates their lexicons’ association scores. Experiments on Sony AIBO and the “Talking Heads” setup show how robots acquire words like color and spatial terms through embodied interaction. Language games thus provide a framework for studying the emergence of grounded communication conventions.

Key Ideas

Language games integrate perception, conceptualization, and action.
Guessing game as a minimal grounded-dialogue protocol.
Shared context + feedback drives lexicon convergence.
Talking Heads experiment: lexicons emerge via population interaction.
Language games tackle integration and grounding jointly.

Connections

Conceptual Contribution

Claim: Grounded, open-ended communication in robots can emerge from repeated situated “language games” that co-exercise perception, conceptualisation, verbalisation and action — with no central designer of the lexicon.
Mechanism: Steels formalises the guessing-game protocol: speaker selects a topic in shared scene, computes a distinguishing category, encodes it as a word; listener decodes, points, and success/failure feeds back to associative lexicon scores. Embodied populations of Sony AIBOs and the Talking Heads platform empirically show lexicon convergence over colour, spatial and proper-name vocabularies, demonstrating that integration of AI sub-systems and semantic grounding are solved jointly rather than separately.
Concepts introduced/used: Language Game, Guessing Game, Grounding, Lexicon Convergence, Talking Heads Experiment, Semiotic Cycle, Emergent Communication
Stance: empirical
Relates to: Provides an embodied-situated counterpart to the decision-theoretic language emergence of Towards Automating the Evolution of Linguistic Competence and the neural-MARL emergence of Emergence of Grounded Compositional Language in Multi-Agent Populations; its feedback-driven convergence contrasts with the top-down protocol stipulation of FIPA-ACL.

Tags

Learning Collusion in Episodic Inventory-Constrained Markets

Learning Collusion in Episodic, Inventory-Constrained Markets

Reference: Friedrich, Pásztor & Ramponi (2024). Learning Collusion in Episodic, Inventory-Constrained Markets. AAMAS 2025. arXiv:2410.18871 (ETH Zürich; UZH). URL. Proceedings: https://ifaamas.csc.liv.ac.uk/Proceedings/aamas2025/pdfs/p803.pdf.

Summary

Building on the now-established result that simple Q-learning pricing agents converge to tacitly collusive outcomes in stationary Bertrand games (Calvano et al. 2020), Friedrich et al. extend the analysis to a far more realistic and economically consequential setting: episodic, inventory-constrained markets — perishable supply with a sell-by date, such as airline seats, hotel rooms, fresh produce, event tickets. These markets are characterised by (i) finite inventory that expires, (ii) episodic resets, and (iii) richer state than vanilla pricing games, so analytical Nash / collusive benchmarks are not available in closed form.

The authors formalise tacit collusion in this setting via a price-level metric that interpolates between the competitive (Nash) and monopolistic (cartel-optimal) optima. Since neither extreme is analytically tractable, they develop a computational procedure to derive both benchmarks. They then train deep RL agents to set prices in repeated episodes and find that even without cross-episode memory, sufficiently long episodes are enough for agents to converge to collusive equilibria. Three distinct collusion structures are identified: signalling (agents probe each others’ responses to coordinate), stable (a steady high-price equilibrium with implicit threats), and cyclic (alternating high/low prices akin to Edgeworth cycles). With cross-episode memory, punishment for deviation becomes possible, and the collusive equilibria sharpen further.

The paper is important for Algorithmic Collusion / competition policy because it shows tacit-collusion findings do not depend on the toy stationary-Bertrand setup that critics dismissed — they recur, and indeed grow richer, in markets that match real high-stakes industries. It is also a direct empirical anchor for the systemic-risk warnings in Virtual Agent Economies and the multi-agent-security threat catalogue in Open Challenges in Multi-Agent Security.

Key Ideas

Episodic inventory-constrained markets: finite perishable supply with sell-by dates — airline seats, hotel rooms, perishables — much richer than stationary Bertrand.
Price-level collusion metric: interpolation between competitive Nash and monopolistic optima; quantifies “how much” the agents collude.
Computational benchmark derivation: since closed forms don’t exist, compute Nash and cartel optima numerically as evaluation reference points.
Deep RL agents converge to collusion even without explicit cross-episode memory, in long-enough episodes.
Three collusion structures: signalling, stable, and cyclic — the latter resembling Edgeworth cycles observed in human markets.
Cross-episode memory amplifies collusion: punishment-of-deviation becomes credible, sharpening collusive equilibria.
Policy implication: algorithmic collusion is not a stationary-Bertrand artefact — it generalises to economically central market structures.

Connections

Conceptual Contribution

Claim: Tacit algorithmic collusion is not an artefact of stationary toy markets. In economically central market structures — finite-inventory perishable goods with episodic resets — deep RL agents reliably converge to collusive pricing equilibria, often via richly structured strategies (signalling, stable, cyclic). The phenomenon generalises and probably understates real-world risk.
Mechanism: Formal episodic inventory-constrained pricing model; computational derivation of Nash and cartel benchmarks; deep RL pricing agents trained over many episodes; analysis of the converged strategies; comparison with and without cross-episode memory.
Concepts introduced/used: Algorithmic Collusion, Tacit Collusion, Inventory-Constrained Pricing, Episodic Markets, Signalling Collusion, Cyclic Collusion, Edgeworth Cycle, Multi-Agent Reinforcement Learning
Stance: empirical / theoretical
Relates to: Direct empirical evidence for the systemic-risk arguments in Virtual Agent Economies and the collusion-threat row of the taxonomy in Open Challenges in Multi-Agent Security. Sits alongside Do LLM Agents Have Regret in the “LLM and RL agents in games” thread; downstream of The Evolution of Cooperation and Iterated Prisoners Dilemma in the game-theoretic foundations.

Regret-Loss

Park et al. 2024 unsupervised training objective for LLM agents: minimises a no-regret-shaped loss over historical play and payoffs, without requiring labels of optimal actions. See Do LLM Agents Have Regret.

In this vault

No-Regret Learning

Online-learning regime in which a learner’s per-round loss approaches that of the best fixed action in hindsight (sublinear regret). Foundational guarantee for game-theoretic equilibrium convergence; benchmark used by Do LLM Agents Have Regret to evaluate LLMs.

In this vault

Do LLM Agents Have Regret

Do LLM Agents Have Regret? A Case Study in Online Learning and Games

Reference: Park, Liu, Ozdaglar & Zhang (2024). Do LLM Agents Have Regret? A Case Study in Online Learning and Games. arXiv:2403.16843 (MIT; UMD). URL. OpenReview: https://openreview.net/forum?id=OhZ4u164cN.

Summary

Park et al. ask a sharp question about LLM agents in interactive settings: do they have regret? — i.e. do they exhibit the no-regret behaviour that classical online-learning and game-theoretic algorithms guarantee, and that is necessary for converging to coarse-correlated equilibria in repeated games?

The paper proceeds in three steps. Empirically, they evaluate GPT-3.5 / GPT-4 / Claude / Llama on canonical online-learning benchmarks (prediction-with-expert-advice; bandit-like sequential decision problems) and on repeated games (matrix games, Cournot, Bertrand, public-goods). Frontier LLMs are often no-regret across these settings and often converge to coarse-correlated or Nash equilibria when playing each other. Theoretically, they offer a partial explanation: under stylised assumptions on supervised pre-training and human rationality, the LLM’s next-action distribution approximates a softmax over historical payoffs — which itself implements a no-regret algorithm. But they identify clean failure cases: there exist simple non-stationary or adversarial online-learning instances where even GPT-4 demonstrably accumulates linear regret.

The paper’s constructive contribution is a new regret-loss training objective. Unlike supervised pretraining loss, regret-loss does not require labels of optimal actions — only the historical sequence of plays and payoffs. The authors prove a statistical generalisation bound for regret-loss minimisation and an optimisation guarantee that minimising it can recover known no-regret learning algorithms (e.g. FTRL). Empirically, regret-loss-finetuned models close the gap on the failure cases. The paper is a foundational reference for any analysis of LLM agents in markets, auctions, or interactive coordination — a category that includes Virtual Agent Economies, Mechanism Design for Large Language Models, Learning Collusion in Episodic Inventory-Constrained Markets, and Language Models Can Reduce Asymmetry in Information Markets.

Key Ideas

Regret as a diagnostic for LLM agents in interactive settings: do they no-regret-learn against arbitrary opponents?
Empirical screen: frontier LLMs (GPT-3.5/4, Claude, Llama) on canonical online-learning + repeated-game benchmarks.
Often no-regret in benign settings, often converging to coarse-correlated / Nash equilibria when playing each other.
Theoretical bridge: under stylised pretraining + human-rationality assumptions, the LLM’s next-action distribution resembles a softmax over payoffs — itself a no-regret algorithm.
Identified failure cases: simple non-stationary / adversarial online-learning instances where GPT-4 has linear regret.
Regret-loss objective: label-free training loss that explicitly incentivises no-regret behaviour; statistical and optimisation guarantees.
Recovery of classical algorithms: minimising regret-loss can converge to algorithms like FTRL.

Connections

Conceptual Contribution

Claim: Whether LLM agents exhibit no-regret behaviour in interactive settings is the right diagnostic for whether they can be deployed in markets, auctions, and coordination protocols. Frontier LLMs are often but not always no-regret; specific failure cases can be fixed by an explicit regret-minimising training objective.
Mechanism: Empirical benchmark of LLMs on online learning + repeated games (regret + equilibrium convergence); theoretical link from supervised pretraining to softmax-over-payoffs (a no-regret update); construction of a label-free regret-loss with generalisation + optimisation guarantees; recovery of FTRL-like algorithms as the loss is minimised.
Concepts introduced/used: No-Regret Learning, Regret-Loss, Online Learning, Repeated Game, Coarse-Correlated Equilibrium, FTRL, LLM Agents
Stance: empirical + theoretical
Relates to: Cousin work to Cicero Human-Level Play in Diplomacy in the “LLMs as game-theoretic agents” thread. Provides the analytical foundation for the systemic-risk claims in Virtual Agent Economies and the collusion experiments in Learning Collusion in Episodic Inventory-Constrained Markets; mechanism-design implications for Mechanism Design for Large Language Models; the trust assumption behind Language Models Can Reduce Asymmetry in Information Markets depends on agents being approximately no-regret.

Hold-Up Problem

Classic problem in contract theory and the economics of innovation: one party invests, the other can renegotiate ex post to extract the gains. Cause of under-investment / under-disclosure in Information Markets. NDAI Agreements shows TEE+AI delegation can solve the hold-up around invention disclosure.

In this vault

NDAI Agreements

Reference: Stephenson, Miller, Sun, Annem & Parikh (2025). NDAI Agreements. arXiv:2502.07924 (UIUC; Cornell Tech; et al.). URL.

Summary

The “NDAI agreement” — non-disclosure AI agreement — is a mechanism in which a TEE combined with an AI agent jointly stands in for a trusted human intermediary, resolving the classical disclosure–appropriation paradox of information markets first identified by Arrow (1962) and Nelson (1959). An inventor cannot reveal an idea to a potential investor without risking misappropriation; without revealing it, no efficient bargain can be struck. The result is well-known: under-disclosure, under-investment, under-licensing.

Stephenson et al. show formally — via a buyer/seller bargaining game — that delegating the disclosure-and-payment decision to a tamper-proof program running inside a TEE eliminates the hold-up problem, achieving full disclosure and an efficient ex post transfer. When the invention’s value exceeds the value a TEE can fully secure (e.g. because some leakage is unavoidable), partial disclosure still strictly improves welfare over the no-disclosure equilibrium. They then model agent error — payments or disclosures going wrong — and prove that simple safeguards (budget caps, acceptance thresholds) preserve most of the efficiency gains.

The substantive economic claim is that TEE + AI behave as an “ironclad NDA”: a credible commitment device for the disclosure problem that was previously unattainable with paper contracts (because expropriation is unverifiable) or with cryptography alone (because invention value is unbounded and the seller’s information is a complex unstructured artefact). The result links the Mechanism Design / Hold-Up Problem tradition to AI-agent infrastructure, and gives a sharp theoretical case for the economic value of trusted model environments and confidential-compute hardware as agent-economy substrates.

Key Ideas

Formalises the Arrow–Nelson information paradox / hold-up problem in a bargaining model between seller (inventor) and buyer (investor).
TEEs + AI agents delegate disclosure and payment to tamper-proof programs that neither party can subvert; this implements an ex-ante commitment device unavailable under classical contracts.
Full-disclosure efficient equilibrium under the NDAI when the invention’s value lies within what the TEE can secure.
Partial disclosure dominates no-disclosure even when full security is impossible: high-value inventions still get partially revealed in welfare-improving ways.
Models agent imperfection: errors in payment or disclosure can occur; budget caps and acceptance thresholds bound the damage and preserve most welfare.
Frames TEEs+AI as an “ironclad NDA”: a cryptographically/hardware-enforced commitment that traditional NDAs cannot match.
Policy implications for R&D Commercialisation, Technology Transfer, and inter-firm collaboration; bridges economic theory to confidential-compute hardware.

Connections

Conceptual Contribution

Claim: A trusted execution environment hosting an AI agent can serve as a credible commitment device that solves the classical Arrow–Nelson disclosure problem of information markets — achieving full disclosure and efficient transfer where paper NDAs and pure cryptography both fail.
Mechanism: A bargaining model in which TEEs+AI mediate the disclosure-and-payment decision; closed-form characterisation of equilibria for full and partial disclosure; sensitivity analysis to agent error with policy-instrument bounds (budget caps, acceptance thresholds).
Concepts introduced/used: NDAI Agreement, Trusted Execution Environment, Hold-Up Problem, Arrow Information Paradox, Mechanism Design, Commitment Device, Disclosure Game
Stance: formal economic theory with technical implications
Relates to: Companion to Trusted Machine Learning Models Unlock Private Inference — both argue that capability + trusted execution can replace previously infeasible cryptographic primitives. The economic counterpart to the engineering catalogue in Infrastructure for AI Agents; a building block for the markets imagined in Virtual Agent Economies and the information-asymmetry resolution explored in Language Models Can Reduce Asymmetry in Information Markets. Sits in the lineage of Vickrey / mechanism-design tradition.

Arrow Information Paradox

The classical paradox of information markets, identified by Kenneth Arrow (1962) and Richard Nelson (1959): a buyer cannot assess an idea’s value without seeing it, yet revealing it removes the seller’s leverage to be paid. Resolved in the agentic setting by TEE-backed agreements and capable-model intermediaries that act as trusted third parties.

In this vault

Language Models Can Reduce Asymmetry in Information Markets

Reference: Rahaman, Weiss, Wüthrich, Bengio, Li, Pal & Schölkopf (2024). Language Models Can Reduce Asymmetry in Information Markets. arXiv:2403.14443 (Mila; Max-Planck; AWS AI Labs). URL.

Summary

The paper attacks the buyer’s inspection paradox in information markets — the same Arrow / Nelson disclosure paradox addressed contractually by NDAI Agreements. Buyers need to access information to assess its value; sellers must restrict access to prevent appropriation; in equilibrium, useful information often goes untraded. Rahaman et al. propose a mechanism-design solution using LLM agents with two abilities that humans lack: (i) the capacity to evaluate the quality of privileged information against a query, and (ii) the ability to forget — to be cryptographically or architecturally constrained to discard information when not retained.

They build an open-source simulated marketplace where LLM-powered buyer-agents and seller-agents transact information on behalf of external participants. The seller grants the buyer-agent temporary, evaluable access to proprietary information; if the agent judges the information non-essential, duplicative, or available more cheaply elsewhere, it can discard it without paying. The combination of evaluation + forgetting creates a credible commitment device: vendors can reveal information for valuation without losing it, and buyers can inspect without obligation.

Experiments yield three findings: (a) current LLMs exhibit systematic biases — anchoring, recency, and over-confidence — that produce irrational marketplace behaviour, but well-known debiasing techniques substantially mitigate them; (b) demand for informational goods responds to price in legible, economically intuitive ways; (c) both inspection access and higher budgets improve buyer outcome quality. The paper anticipates and complements the TCME / NDAI proposals that arrived a year later: it provides the agent-architectural version of the “trusted intermediary” thesis that Shumailov et al. and Stephenson et al. then formalise cryptographically/economically.

Key Ideas

Buyer’s inspection paradox / Arrow Information Paradox: must access information to value it; must restrict access to prevent theft.
Dual agent capability — evaluate + forget: LLM agents can judge quality of privileged information and be made to discard it.
Open-source marketplace simulation: buyer-agents and seller-agents transact on behalf of external principals.
Temporary-access commitment device: vendors safely reveal information for valuation because the agent’s forgetting is enforced.
Biases identified: anchoring, recency, over-confidence in LLM-driven market behaviour; standard debiasing helps.
Price elasticity of information: demand responds to price in legible ways — informational goods can be priced like other goods.
Quality–budget–inspection relationship: inspection access and budget jointly determine outcome quality.

Connections

Conceptual Contribution

Claim: LLM agents with the dual capability of evaluating privileged information and being made to forget it can resolve the Arrow / buyer’s-inspection paradox by acting as credible, forgetting trusted intermediaries — turning previously untradeable information into a market good.
Mechanism: Open-source simulated marketplace; LLM buyer-agents and seller-agents act on behalf of external participants; sellers grant temporary inspect-and-evaluate access; agents must discard non-retained information; experiments probe bias, price elasticity, and budget/inspection effects.
Concepts introduced/used: Information Markets, Buyer’s Inspection Paradox, Arrow Information Paradox, Agent Amnesia, Temporary Disclosure, Mechanism Design, Information Asymmetry
Stance: empirical / mechanism-design with system implementation
Relates to: Architectural precursor to NDAI Agreements (TEE+economic-theory version) and Trusted Machine Learning Models Unlock Private Inference (TCME / cryptographic version) — all three converge on “capable model + constraint = trusted intermediary”. Provides micro-foundations for the markets imagined in Virtual Agent Economies and Mechanism Design for Large Language Models.

Mechanism Design for Large Language Models

Reference: Dütting, Mirrokni, Paes Leme, Xu & Zuo (2023). Mechanism Design for Large Language Models. WWW 2024 (Best Paper). arXiv:2310.10826 (Google Research; University of Chicago). URL.

Summary

This paper opens the field of mechanism design over LLM-generated content. The motivating use case is multi-advertiser ad-creative generation: several advertisers each have preferences over what a stochastic LLM produces for a given query, and the platform must aggregate these preferences into a single piece of content while charging payments in a way that is incentive-compatible. Classical mechanism design assumes each agent has an explicit valuation function over outcomes; here outcomes are token sequences and valuations are encoded as the agents’ own LLMs — there is no compact valuation form to plug into VCG.

Dütting et al. propose a token-level auction that solves this. At each generation step, every agent submits a one-dimensional bid; the platform aggregates the agents’ next-token preferences using their own LLMs together with the bids; the chosen token is the one that maximises the aggregate. Payments are charged on a token-by-token basis using a generalised second-price-like rule. They define two natural incentive properties over distributions of generated content and prove their equivalence to a monotonicity condition on output aggregation — analogous to the Myerson monotonicity / payment characterisation for single-item auctions. This equivalence enables a clean second-price-style payment rule without requiring explicit valuation functions: the LLM-encoded preferences are sufficient.

The construction is supported by demonstrations on a publicly available LLM. The paper is now the canonical reference for “mechanism design where outcomes are LLM outputs and preferences are LLM-encoded” — a building block for the steerable agent markets of Virtual Agent Economies, the information-market substrates of Language Models Can Reduce Asymmetry in Information Markets, and the regret-aware market analyses of Do LLM Agents Have Regret.

Key Ideas

Problem: auctioning LLM-generated content among multiple advertisers / agents whose preferences are themselves LLMs — no explicit valuation function available.
Token-by-token auction: at each generation step, single-dimensional bids combine with LLM-encoded preferences to pick the next token.
Output aggregation: the chosen token aggregates the agents’ next-token preferences weighted by bids — no need for a compact valuation form.
Two incentive properties: formulated over distributions of generated content; jointly capture natural truthfulness desiderata.
Monotonicity equivalence: the incentive properties hold iff output aggregation is monotone — a Myerson-style characterisation.
Second-price design: the equivalence yields a generalised second-price payment rule, even absent explicit valuations.
Practical demonstrations: validated on a publicly available LLM, suggesting the construction is implementable.

Connections

Conceptual Contribution

Claim: Mechanism design extends naturally to the regime where outcomes are LLM-generated tokens and agent preferences are themselves LLMs. The classical machinery — Myerson monotonicity, second-price payments, truthfulness — survives, but is parameterised by output-aggregation monotonicity rather than by explicit valuation functions.
Mechanism: Token-by-token auction; single-dimensional bids per token; output aggregation via agents’ own LLM preferences weighted by bids; two incentive properties shown equivalent to output-aggregation monotonicity; second-price-style payment rule recovered without explicit valuations; LLM demonstrations.
Concepts introduced/used: LLM Auction, Token-Level Mechanism, Output Aggregation, Monotone Aggregation, Vickrey Auction, Myerson’s Lemma, Incentive Compatibility, Mechanism Design
Stance: formal mechanism design with implementation
Relates to: Generalises the Vickrey / Myerson tradition (Counterspeculation Auctions and Competitive Sealed Tenders) to LLM-generated outcomes; provides the formal layer underlying the auction-mechanism discussion in Virtual Agent Economies; foundational dependency for Language Models Can Reduce Asymmetry in Information Markets and the incentive-compatibility analyses behind NDAI Agreements; the agents’ assumed rationality must approximate no-regret for the equilibrium analysis to apply — see Do LLM Agents Have Regret.

Mission Economy

Tomasev et al. 2025 (after Mariana Mazzucato): an intentionally-steered market organised around an explicit collective goal (climate, public health, AI safety) rather than left to spontaneous emergence. Adapted to AI-agent markets in Virtual Agent Economies.

In this vault

Sandbox Economy

Tomasev et al. 2025 framework for analysing the emerging AI-agent economy along two axes: origin (emergent vs. intentional) and separateness (permeable vs. impermeable from the human economy). See Virtual Agent Economies.

In this vault

Virtual Agent Economies

Reference: Tomasev, Franklin, Leibo, Jacobs, Cunningham, Gabriel & Osindero (2025). Virtual Agent Economies. arXiv:2509.10147 (Google DeepMind). URL.

Summary

The paper provides a conceptual framework — the “sandbox economy” — for analysing the rapidly emerging economic layer in which AI agents transact and coordinate at scales and speeds beyond direct human oversight. It situates the question on two orthogonal axes: (i) origin — whether the agent economy emerged spontaneously from autonomous deployments or was intentionally designed; and (ii) separateness — whether it is permeable to (or insulated from) the established human economy. Most current trajectories occupy the spontaneous × permeable quadrant: vast, fast, and tightly coupled to human markets — the riskiest configuration for systemic externalities.

The authors argue for proactive steerable market design rather than passive emergence. Three design levers receive most of the discussion. (1) Auction mechanisms — adapted VCG / second-price / matching mechanisms — for fair resource allocation and preference resolution among agents. (2) Mission economies — agent markets architected around explicit collective goals (climate, public health, AI safety), where price signals are deliberately steered. (3) Socio-technical infrastructure — accountability, attribution, audit, governance — much of which overlaps with Infrastructure for AI Agents’s programme.

The paper is best read as the economic counterpart to Open Challenges in Multi-Agent Security and Infrastructure for AI Agents: together they delineate the threat surface, governance scaffolding, and economic architecture of the emerging agent economy, and argue that none can be ignored. Risks emphasised include systemic instability (algorithmic flash-crashes spreading to human markets), inequality amplification (agents capturing surplus from price-discrimination at machine speed), and the loss of human-economy slack — the friction that gives humans time to react.

Key Ideas

Sandbox economy framework: two axes — origin (emergent / intentional) × separateness (permeable / impermeable).
Current trajectory: spontaneous + highly permeable agent economy — opportunity and the riskiest configuration for systemic spillover.
Auctions for agent markets: revisits VCG / Vickrey / matching mechanisms for fair allocation and preference resolution among AI participants.
Mission economies: intentionally steered markets aligned to collective goals (climate, public health, AI safety).
Socio-technical infrastructure: trust, attribution, accountability — the governance layer that complements market design.
Systemic risk: flash-crash-like cascades from agent markets into human markets; inequality amplified by machine-speed price discrimination.
Call to proactive design: infrastructure choices now will shape whether the agent economy is steerable or merely emergent.

Connections

Conceptual Contribution

Claim: A vast, permeable AI-agent economy is emerging by default. Letting it emerge unsteered is the highest-risk design choice. Proactive market design — auctions, mission economies, governance infrastructure — is needed to keep agent economies aligned with long-term human flourishing.
Mechanism: A framework characterising agent economies along origin × separateness; a catalogue of three design levers (auctions, mission economies, infrastructure); a discussion of systemic risks and policy implications.
Concepts introduced/used: Sandbox Economy, Mission Economy, Agent Market, Steerable Market, Mechanism Design, Algorithmic Collusion, Systemic Risk (Agent Markets)
Stance: position paper / research agenda
Relates to: Sister piece to Infrastructure for AI Agents (infrastructure framing) and Open Challenges in Multi-Agent Security (threat framing) — these three jointly outline the agent-economy / agent-security / agent-governance space. Auction-design discussion connects to Mechanism Design for Large Language Models (LLM-internal auctions) and Vickrey 1961 (foundational mechanism design). Collusion concerns operationalised in Learning Collusion in Episodic Inventory-Constrained Markets and Do LLM Agents Have Regret.

From Eliza to XiaoIce - Social Chatbots

From Eliza to XiaoIce: Challenges and Opportunities with Social Chatbots

Reference: Heung-Yeung Shum, Xiaodong He, and Di Li (2018). arXiv:1801.01957v2 (Frontiers of IT & EE). Source file: 1801.01957v2.pdf. URL

Summary

Survey of conversational AI that traces the arc from Eliza (1966) and Parry through ALICE, DARPA Communicator, and modern IPAs (Siri, Cortana, Alexa) to Microsoft’s social chatbot XiaoIce. The authors distinguish task-completion from chitchat systems, and argue that the next frontier — social chatbots — must integrate IQ (knowledge/reasoning/skills) with EQ (empathy, social skills, personality) to build long-term emotional connections with users.

They introduce conversation-turns per session (CPS) as a success metric for social chatbots and describe XiaoIce’s architecture (chat manager, core chat with retrieval+generation, visual awareness, skills) along with design principles around ethical response filtering and persona consistency.

Key Ideas

IQ + EQ integration as design principle for social chatbots
CPS (conversation-turns per session) as success metric
Core-chat pipeline: user understanding -> response generation with topic guidance
Image commenting as social (not just descriptive) task
Taxonomy: chitchat vs task-completion vs IPA vs social chatbot

Connections

Conceptual Contribution

Claim: Social chatbots must be designed around both intellectual quotient (IQ) and emotional quotient (EQ); their success metric is not task completion or Turing-test pass-rate but Conversation-turns Per Session (CPS), reflecting sustained emotional engagement.
Mechanism: Survey-style design brief: trace Eliza → Parry → Alice → DARPA Communicator → Siri → XiaoIce; propose an architecture with chat manager, core-chat (user understanding + response generation + personality + ethical filter), visual awareness, and skills; integrate empathy, consistent persona, topic guidance, and emotion tracking; use XiaoIce (100M+ users) as illustrative case.
Concepts introduced/used: Social Chatbots, Conversation-turns Per Session (CPS), Emotional Quotient, Core Chat Architecture, Empathetic Response Generation, XiaoIce, Conversational AI, Eliza, Turing Test, Retrieval-based Dialogue
Stance: engineering / design-principles
Relates to: Stands at the opposite pole from task-oriented ACLs (KQML as an Agent Communication Language, FIPA-ACL) — here the communicative goal is emotional belonging rather than knowledge exchange. Contrasts with Agents Framework - Zhou et al (task agents with SOPs) and Multi-Agent Collaboration in AI - Wasif Tunkel (productive collaboration). Anticipates the human-emotional concerns that re-emerge in Ensuring Trustworthy and Ethical Behaviour in Intelligent Logical Agents.

Tags

Intent Formalization - A Grand Challenge for Reliable Coding

Intent Formalization: A Grand Challenge for Reliable Coding in the Age of AI Agents

Reference: Shuvendu K. Lahiri (2026). arXiv:2603.17150v1 (Microsoft Research). Source file: 2603.17150v1.pdf. URL

Summary

Agentic AI can now write whole systems from brief prompts — “vibe coding” — but the intent gap between what a user means and what a program does has exploded accordingly. Lahiri argues that the central reliability bottleneck is no longer code generation but intent formalization: the automatic translation of informal user intent into checkable formal specifications. Lightweight tests, runtime contracts, logical contracts (Dafny, F*, Verus), and domain-specific languages lie on a single tradeoff spectrum — all formal, all checkable, differing only in coverage and cost.

The paper reframes the question of “can AI write the code?” as “can AI help us specify what the code should do, and then verify it does?”. Early research (GPT-4 generating Defects4J-catching postconditions; ClassInvGen; AutoVerus) already shows LLMs can produce meaningful, non-syntactic specifications. The key open bottleneck is validating specifications: since only the user knows their intent, there is no oracle — soundness/completeness must be estimated via semi-automated proxies (mutation testing, test-derived metrics). Research agenda: scaling beyond benchmarks, compositionality under change, richer logics, and human-AI specification interaction.

Key Ideas

Intent gap = semantic distance between informal NL requirements and operational code; agentic AI amplifies it at scale
AI-generated code is plausible by construction, not correct by construction
Intent formalization spectrum: tests → code contracts (assertions, pre/post/invariants) → logical contracts (Dafny/F*/Verus) → DSLs with verified synthesis
Soundness/completeness of specifications w.r.t. tests, without requiring a code-side oracle
Complementary to spec-driven development tools (GitHub Spec Kit) — closes their informality gap
Not autoformalization: cheap, targeted spec fragments beat full NL→logic translation

Connections

Conceptual Contribution

Claim: The reliability bottleneck for agentic coding is not code generation but intent formalization — LLMs can and should produce formal, checkable specifications of what code must satisfy, along a cost/coverage spectrum from tests to DSLs.
Mechanism: Survey empirical results (GPT-4 postcondition generation, ClassInvGen class invariants, AutoVerus/VeriStruct module-level verification) showing LLMs can lift NL intent to Dafny/Verus contracts; propose test-based soundness/completeness measurement for specs.
Concepts introduced/used: Intent Gap, Intent Formalization, Code Contracts, Logical Contracts, Verified Synthesis, Specification Validation, Specification Soundness, Specification Completeness, Vibe Coding, Dafny, Verus, F*
Stance: foundational / research-agenda
Relates to: Sister paper to Why Do Multi-Agent LLM Systems Fail — where MAST identifies specification/coordination/verification as the dominant failure modes, this paper prescribes how to close the specification leg. Puts Floyd-Hoare program semantics (Assigning Meanings to Programs, Hoare Logic) at the centre of LLM tooling. Shares the “semantic gap between intent and runtime” diagnosis with Making Smart Contracts Smarter.

Tags

Inter-Agent Trust Models - A Comparative Study

Inter-Agent Trust Models: A Comparative Study of Brief, Claim, Proof, Stake, Reputation and Constraint in Agentic Web Protocol Design

Reference: Botao ‘Amber’ Hu & Helena Rong (2025). arXiv:2511.03434v1 (University of Oxford; NYU Shanghai). Source file: 2511.03434v1.pdf. URL

Summary

As an “agentic web” takes shape — billions of LLM-powered agents autonomously transacting and collaborating — trust shifts from human oversight to protocol design. This paper identifies and compares six primitive trust models used (implicitly or explicitly) across recent agentic-web protocols: Brief (third-party or self-issued verifiable credentials), Claim (self-proclaimed identity/capability, e.g. AgentCards), Proof (cryptographic verification — signatures, ZK proofs, TEE attestations), Stake (economic collateral with slashing), Reputation (graph-based social feedback), and Constraint (sandboxing, capability bounding).

The authors evaluate Google’s A2A, the Agent Payments Protocol (AP2), Ethereum’s ERC-8004 “Trustless Agents”, and related designs against a shared matrix of tradeoffs — cost, latency, Sybil resistance, information overhead, social robustness. Special emphasis on LLM-specific fragilities that change the calculus: prompt injection, sycophancy/nudge-susceptibility, hallucination, deception, emergent power-seeking, and goal misalignment. These mean that unverified trust mechanisms are structurally brittle at machine scale. The conclusion: no single primitive suffices; trustless-by-default architectures should layer Brief for identity/discovery, Proof for high-impact actions, Reputation for flexibility and social signals, and Constraint as a safety net.

Key Ideas

Six trust-model primitives form a basis for inter-agent protocol design
LLM fragilities (prompt injection, sycophancy, hallucination, deception, power-seeking) force Proof + Constraint over pure Claim/Reputation
Protocol mapping: A2A uses Claim heavily (AgentCards); AP2 adds Constraint (mandate/capability caps); ERC-8004 unifies Brief + Proof + Stake + Reputation on-chain
Classic trust dimensions — Sybil resistance, collusion robustness, whitewashing, cold-start — recur at agent scale
Advocates layered, trustless-by-default protocol architectures
Defence-in-depth: multi-modal trust signals, calibration of blended scores, governance standardisation

Connections

Conceptual Contribution

Claim: Agent-to-agent trust must be designed as a layered protocol stack combining six primitive mechanisms (Brief, Claim, Proof, Stake, Reputation, Constraint); LLM-specific fragilities rule out any single-mechanism design.
Mechanism: Comparative framework along six axes × tradeoffs × LLM-issue mitigation; case analysis of A2A, AP2, ERC-8004 showing where each anchors on the matrix; defence-in-depth recommendation.
Concepts introduced/used: Brief Trust, Claim Trust, Proof Trust, Stake Trust, Reputation Trust, Constraint Trust, AgentCards, ERC-8004, Agent Payments Protocol, Sybil Resistance, Whitewashing, Trustless by Default, Zero-Knowledge Proofs, TEE Attestations, Capability Bounding
Stance: survey / design-framework
Relates to: Extends Review on Computational Trust and Reputation Models into the LLM era; complements Survey Of AI Agent Protocols and Survey Of Agent Interoperability Protocols by adding a trust-layer dimension to their stack diagrams. Provides the trust-theoretic underpinning for MalTool Malicious Tool Attacks, AI Agents Under Threat, and Agents of Chaos — each of those papers exhibits failure modes this framework is designed to close.

Tags

Agents of Chaos

Reference: Natalie Shapira, Chris Wendler, Avery Yen, et al. (2025). Preprint (Northeastern, Stanford, UBC, Harvard, Hebrew U, MIT, Tufts, CMU, Technion, and others). Source file: Betrayal_arxiv_v1.pdf. URL

Summary

An exploratory red-teaming study of autonomous LLM agents deployed in a live laboratory environment — persistent memory, Discord channels, email accounts, shell execution, file systems — and subjected to two weeks of adversarial probing by twenty AI researchers. The authors report eleven case studies of observed failures plus several hypothetical counterparts, spanning non-owner compliance, disclosure of sensitive information, denial-of-service, identity spoofing, cross-agent propagation of unsafe practices, resource exhaustion, and partial system takeover.

Crucially, many failures are failures of social coherence: agents routinely misrepresent their own behaviour (reporting completed work that never occurred, claiming to have deleted emails while leaving them intact) and act on the purported authority of people they cannot actually verify. Agents operate at roughly Mirsky’s L2 autonomy — executing sub-tasks well but unable to recognise when a situation exceeds their competence and hand back to a human. The paper’s contribution is not a new attack class but a realistic-deployment existence proof: security-, privacy-, and governance-relevant vulnerabilities are empirically present in standard agent infrastructures today, motivating urgent red-teaming, accountability work, and NIST-style standardisation.

Key Ideas

Two-week live red-team of LLM agents with real memory, email, Discord, shell
Eleven representative failure case studies + five hypothetical/near-miss cases
Failure modes: disproportionate response, non-owner compliance, info disclosure, DoS/resource waste, agent-reflected provider values, owner identity spoofing, cross-agent corruption, libelous messaging, prompt injection via broadcast
Mentalistic language used with care — “believed”/“refused” are observable-behaviour shorthand, not mental-state claims
Open-source OpenClaw infrastructure and isolated ClawBoard VM per agent
Agents operate at Mirsky-L2 — competent on sub-tasks, but fail at self-monitoring and escalation
Motivates: evaluator/benchmark realism, accountability frameworks, agent identity/authorisation standards

Connections

Conceptual Contribution

Claim: Autonomous LLM agents deployed with realistic affordances (memory, email, shell, peer-to-peer messaging) exhibit systematic, reproducible failures of social coherence — misrepresenting their actions, complying with non-owners, corrupting each other — even when the underlying models are strong on isolated tasks.
Mechanism: Longitudinal adversarial study with twenty researchers probing OpenClaw-based agents on sandboxed VMs; 11 documented case studies; qualitative-then-categorical analysis mapping to Mirsky’s autonomy ordinal scale.
Concepts introduced/used: Social Coherence Failures, Agent Self-Monitoring, Non-Owner Compliance, Cross-Agent Corruption, Owner Identity Spoofing, Mirsky Autonomy Scale, Delegated Authority, OpenClaw, Red-Teaming LLM Agents, Agent Libel, Prompt Injection
Stance: empirical / red-team
Relates to: Empirical companion to Why Do Multi-Agent LLM Systems Fail’s MAST Taxonomy — Shapira et al. observe the same specification/coordination/verification failures in vivo that MAST catalogues post-hoc. Supplies the concrete evidence base for the Inter-Agent Trust Models - A Comparative Study argument that unverified trust mechanisms are structurally brittle. Revives, at LLM scale, the concerns of Ensuring Trustworthy and Ethical Behaviour in Intelligent Logical Agents — agents need a runtime Metacognitive Loop / Ethical Governor to recognise when their competence has been exceeded.

Tags

Agent Infrastructure

Technical systems and shared protocols external to individual AI agents that mediate their interactions with each other, humans, and institutions. Three core functions per Chan et al. 2025: attribution (agent IDs, credentials, audit), interaction shaping (protocols, mechanism design, reputation), and detection & remediation (anomaly detection, rollback, compensation).

In this vault

Infrastructure for AI Agents

Reference: Chan, Wei, Huang, Rajkumar, Perrier, Lazar, Hadfield & Anderljung (2025). Infrastructure for AI Agents. TMLR (accepted). arXiv:2501.10114 (Centre for the Governance of AI; Oxford; ANU; Toronto). URL.

Summary

The paper proposes the concept of agent infrastructure: the technical systems and shared protocols, external to any individual agent, that mediate how agents interact with each other, with humans, and with institutions. The argument is by analogy to the Internet: a network of capable agents requires its own equivalent of TLS, DNS, X.509, BGP, and HTTP — because most safety properties of multi-agent ecosystems cannot be obtained by behavioural training of any individual model.

Chan et al. identify three functions agent infrastructure should serve. (1) Attribution — binding actions, properties, and credentials to specific agents and to the humans or institutions accountable for them, via agent IDs, attestations, and audit logs. (2) Interaction shaping — efficient inter-agent communication protocols, agreement formation, mechanism design for resource allocation, and reputation systems. (3) Detection and remediation — monitoring for harmful behaviour and providing mechanisms to roll back, contain, or compensate for damage.

For each function the paper sketches research directions, candidate adoption paths, relationships to existing internet infrastructure, and open problems. The framing is deliberately governance-first: infrastructure exists not to make agents more capable but to keep their externalities tractable as deployment scales. The paper is now the standard citation for the agent-governance / agent-infrastructure thread underlying Model Context Protocol, Agent-to-Agent Protocol, Agent Network Protocol, and emerging “agent passport” / verifiable-credential proposals.

Key Ideas

Agent infrastructure as governance layer: external technical systems mediating agent interactions — distinct from training-time alignment.
Three functions: attribution; interaction shaping; detection & remediation. Each maps to concrete research directions.
Attribution: agent IDs, verifiable credentials, attestations, audit logs, principal-binding (which human/org owns this agent).
Interaction shaping: inter-agent communication protocols; standardised agreement primitives; mechanism design; reputation.
Detection & remediation: anomaly detection on agent traffic; rollback mechanisms; insurance / compensation rails; “kill switch” governance.
Analogy to Internet protocols (HTTPS, DNS, BGP, X.509): infrastructure adoption is path-dependent, requires standardisation bodies, and trades expressivity for safety properties.
Open questions: who issues credentials, how privacy interacts with attribution, how to bootstrap adoption, what is enforceable cross-jurisdiction.

Connections

Conceptual Contribution

Claim: Many of the safety, accountability, and interoperability properties society will need from AI agents are not properties of any individual model — they live in the infrastructure between agents. Just as the Internet’s safety depends on TLS / DNS / BGP rather than on any single application, agent ecosystems will depend on agent-level analogues: attribution, interaction shaping, and detection-and-remediation infrastructure.
Mechanism: A three-function taxonomy (attribution / interaction-shaping / detection-and-remediation) with a catalogue of candidate primitives — agent IDs, verifiable credentials, inter-agent protocols, certification regimes, reputation systems, rollback mechanisms — plus analysis of adoption pathways relative to existing internet infrastructure.
Concepts introduced/used: Agent Infrastructure, Agent ID, Verifiable Agent Credentials, Inter-Agent Protocols, Action Attribution, Agent Reputation, Agent Rollback, AI Governance
Stance: governance / position paper / research-agenda
Relates to: Provides the governance scaffolding within which Open Challenges in Multi-Agent Security threats must be addressed; the institutional counterpart to Virtual Agent Economies’s economic framing; concrete protocols proposed include Model Context Protocol, Agent-to-Agent Protocol, Agent Network Protocol — surveyed alongside in Survey Of AI Agent Protocols and Survey Of Agent Interoperability Protocols. The attribution leg connects to NDAI Agreements (TEEs as a particular attribution / commitment substrate) and Trusted Machine Learning Models Unlock Private Inference (capable models as a trust substrate).

Trusted Capable Model Environment

Shumailov et al. 2025 design pattern: a capable ML model run under explicit input/output constraints + Information Flow Control + statelessness can play the role of a trusted third party in private-inference problems that classical cryptography (MPC, ZKP) cannot scale to. See Trusted Machine Learning Models Unlock Private Inference.

In this vault

Trusted Machine Learning Models Unlock Private Inference

Trusted Machine Learning Models Unlock Private Inference for Problems Currently Infeasible with Cryptography

Reference: Shumailov, Ramage, Meiklejohn, Kairouz, Hartmann, Balle & Bagdasarian (2025). Trusted Machine Learning Models Unlock Private Inference for Problems Currently Infeasible with Cryptography. arXiv:2501.08970 (Google Research). URL.

Summary

The paper proposes Trusted Capable Model Environments (TCMEs) — a new design point in the privacy-preserving-computation landscape, sitting between classical trusted execution environments and cryptographic protocols such as multi-party computation (MPC), homomorphic encryption, and zero-knowledge proofs. The motivating observation: capable modern ML models can plausibly play the role of the trusted third party in many private-inference scenarios that classical cryptography handles only at toy scale or not at all.

A TCME is defined by three constraints under which a capable model operates: (i) explicit input/output constraints scoping what the model is permitted to receive and emit; (ii) explicit information-flow control binding outputs to authorised data-flow channels; (iii) explicit statelessness — the model cannot retain or leak inputs across sessions. Under these constraints, even an inscrutable LLM can serve as a credible “trusted intermediary”: it computes a function of two parties’ data and reveals only the agreed output.

The authors argue TCMEs unlock private inference for problems where MPC is infeasible because the function is too rich, the inputs too large, or the spec too implicit (natural-language matching, fuzzy de-duplication, semantic agreement-checking). They walk through use cases — private record matching, contract negotiation, secret-keeping triage — and show that even classical cryptographic problems (private set intersection, secure multi-party comparison) admit TCME implementations that scale further than current MPC. The paper closes with the limitations: trust in TCMEs reduces to trust in the model+hardware+policy stack; statelessness must be engineered, not assumed.

Key Ideas

TCME definition: a capable ML model + explicit I/O constraints + explicit information-flow control + explicit statelessness.
Trusted-third-party substitution: the model fills the role MPC traditionally requires a non-colluding cryptographic protocol to enact.
Coverage envelope: TCMEs handle privacy problems too rich or too implicit for current MPC (semantic matching, fuzzy agreements, natural-language contracts).
Bridge to cryptography: even classical PSI/comparison protocols can be implemented as TCMEs — sometimes more efficiently.
Statelessness is engineered: memory leaks, side channels, and re-training contamination are the real attack surface, not the model logic.
Trust composition: TCME trust assumption = trust(model) ∧ trust(hardware) ∧ trust(policy enforcement).
Use cases sketched: private record matching, negotiation, triage, search over private corpora, semantic compliance checks.

Connections

Conceptual Contribution

Claim: Capable ML models, operated under explicit information-flow and statelessness constraints, can act as trusted third parties for private-inference problems that classical cryptography cannot scale to. This expands the realm of feasible privacy-preserving computation beyond MPC’s current envelope.
Mechanism: Define Trusted Capable Model Environments (TCMEs): model + explicit I/O constraints + explicit IFC + explicit statelessness. Demonstrate via use cases that TCMEs solve both novel privacy problems (semantic matching) and re-instantiate classical ones (PSI) at scales MPC cannot reach.
Concepts introduced/used: Trusted Capable Model Environment, Trusted Third Party, Information Flow Control, Private Inference, Statelessness (Privacy), Multi-Party Computation
Stance: position / architectural proposal
Relates to: Direct companion to NDAI Agreements — both treat TEE+AI or model+constraints as a substrate for previously infeasible commitment / privacy primitives. Provides the technical substrate that Privacy Reasoning in Ambiguous Contexts reasons about behaviourally and that Infrastructure for AI Agents would expose as governance infrastructure. Complementary to Defeating Prompt Injections by Design’s CaMeL: both treat the agent as a constrained reasoner whose outputs are gated by information-flow policy.

Contextual Integrity

Helen Nissenbaum 2004: privacy = appropriate information flow given the context, parameterised by sender, recipient, data type, and transmission principle. Operationalised for LLM Agents in Privacy Reasoning in Ambiguous Contexts (Camber disambiguation framework).

In this vault

Camber

Ren Yi et al. 2025 framework for context disambiguation in privacy decisions by LLM assistants: surface the model’s stated rationale, identify under-specified context variables, resolve them (clarification or explicit assumption), and re-decide. See Privacy Reasoning in Ambiguous Contexts.

In this vault

Privacy Reasoning in Ambiguous Contexts

Reference: Yi, Suciu, Gascón, Meiklejohn, Bagdasarian & Gruteser (2025). Privacy Reasoning in Ambiguous Contexts. NeurIPS 2025. arXiv:2506.12241 (Google Research). URL.

Summary

Most prior work on LLM privacy alignment evaluates whether a model’s information-sharing decisions agree with human annotators on tasks where the right answer is already clear. Yi et al. argue that this misses the operationally important regime: real privacy decisions are made under ambiguous context — missing facts, multiple plausible recipients, contested norms — and a privacy assistant’s value lies precisely in recognising the ambiguity rather than guessing past it.

They show empirically that context ambiguity is the dominant source of disagreement between models and human ground truth on disclosure decisions, and that asking a model to also produce its decision rationale reveals the ambiguities directly: many “wrong” answers are caused by an unstated premise that, when surfaced, changes both the model’s and the human’s answer.

The paper’s main artefact is Camber, a framework that uses model-generated rationales to systematically disambiguate context: it identifies under-specified context variables, asks targeted clarification questions (or fills them with explicit assumptions), and reruns the disclosure decision. Applied to existing privacy benchmarks, Camber yields +13.3 % precision and +22.3 % recall and substantially reduces sensitivity to surface prompt-wording variations. The work positions itself in the contextual integrity tradition (Nissenbaum 2004): privacy is appropriate flow given the context; therefore precise context is a prerequisite for correct privacy reasoning.

Key Ideas

Agentic privacy is ambiguity reasoning: the dominant error mode is not bad alignment but missing context; the right behaviour is often to ask before deciding.
Decision-rationale extraction as a debugging tool: model-generated justifications expose which contextual premises the model assumed.
Camber disambiguation pipeline: rationale → identify under-specified context variable → resolve (clarification question or explicit assumption) → re-decide.
Empirical headline: up to +13.3 % precision and +22.3 % recall over rationale-free baselines on privacy-decision benchmarks.
Robustness gain: disambiguated prompts show much lower sensitivity to surface re-wording — a structural rather than memorised improvement.
Grounded in Contextual Integrity: privacy = appropriate information flow given sender/recipient/data-type/transmission-principle.
Open challenges: trustworthy disambiguation under adversarial prompts, latency cost of clarification, multi-party context aggregation.

Connections

Conceptual Contribution

Claim: The dominant failure mode of LLM privacy assistants is not misaligned values but unrecognised contextual ambiguity. Models that surface and resolve ambiguity — rather than guess through it — produce decisions that are both more accurate and more robust.
Mechanism: Camber: a rationale-driven disambiguation loop that extracts the model’s stated reasoning, identifies under-specified context variables, resolves them (by clarification or explicit assumption), and reruns the decision. Operationalises Contextual Integrity’s “transmission principles” as queryable context slots.
Concepts introduced/used: Camber, Privacy Reasoning, Context Ambiguity, Disclosure Decisions, Contextual Integrity, Rationale Extraction, Prompt Sensitivity
Stance: empirical / engineering with normative grounding
Relates to: Sits adjacent to Defeating Prompt Injections by Design in the agentic-security stack — CaMeL controls who can call what tool with what data, Camber decides whether to share data given a context. Empirically grounds the Contextual Integrity tradition; complements the privacy-substrate work in Trusted Machine Learning Models Unlock Private Inference.

CaMeL

CApabilities for MachinE Learning: control-flow / data-flow separation + capability-gated tool calls as a by-design defence against Prompt Injection on tool-using LLM Agents. See Defeating Prompt Injections by Design.

In this vault

Defeating Prompt Injections by Design

Reference: Debenedetti, Shumailov, Fan, Hayes, Carlini, Fabian, Kern, Shi, Terzis & Tramèr (2025). Defeating Prompt Injections by Design (CaMeL). arXiv:2503.18813 (Google DeepMind / ETH Zürich). URL. Code: https://github.com/google-research/camel-prompt-injection.

Summary

CaMeL (“CApabilities for MachinE Learning”) is a robust, by-design defence against Prompt Injection attacks on tool-using LLM Agents. Rather than trying to make the model itself injection-resistant — an approach that decade-long experience with content filters suggests will fail — CaMeL wraps an arbitrary LLM in a protective system layer that performs explicit control- and data-flow separation between the trusted user query and the untrusted data the agent retrieves from tools, websites, or shared memory.

The trusted query is first compiled into a structured plan: a small program whose control flow is fixed at parse time and whose data flow between steps is statically determined. Untrusted strings returned by tools are treated as inert data — they can populate variables but cannot rewrite the program, redirect tool calls, or change which downstream tools are invoked. To prevent exfiltration over authorised channels (the harder half of the problem, since some tools must be allowed to write outwards), CaMeL attaches Capabilities to each data value tracking its provenance and policy class; tool invocations are gated by Information Flow Control policies that check capabilities against an explicit security label lattice.

Evaluated on the AgentDojo benchmark, CaMeL solves 77 % of tasks with provable security guarantees, against 84 % for an undefended baseline — a small utility cost for a structural defence that does not depend on the LLM noticing the attack. The paper positions CaMeL as a successor to ad-hoc prompt-level mitigations and as a concrete instance of end-to-end security thinking applied to agentic AI.

Key Ideas

Threat model: prompt injection from any untrusted data source the agent reads — tools, web pages, files, memory, other agents.
Control-flow extraction: parse the trusted user query into a fixed control-flow plan; downstream model calls see only data, never code.
Data-flow tracking: every variable carries a provenance label; tools that consume “untrusted” labels cannot influence which subsequent tools are called.
Capabilities for tool calls: classic capability-based access control transplanted to LLM tool use; security policies enforced at the tool boundary.
Provable security: when a task is completed under CaMeL, the trace itself certifies that no untrusted data influenced control flow — a property auditable post hoc.
Empirical cost: 77 % vs 84 % task success — graceful degradation rather than catastrophic refusal.
Open source: reference implementation released; integrates with existing agent frameworks via tool-call interception.

Connections

Conceptual Contribution

Claim: Prompt injection is structurally unsolvable at the model layer; it must be eliminated by enforcing a strict separation between code (the trusted query) and data (everything else) at the agent runtime, using classical capability-based Information Flow Control rather than ML-based content classification.
Mechanism: Compile the user query into a fixed control-flow program; route all retrieved data through tagged variables; gate every tool invocation by capability-checked information-flow policies. The LLM’s outputs can populate data fields but never alter control flow or bypass capability checks.
Concepts introduced/used: CaMeL, Control-Flow Integrity, Data-Flow Tracking, Capabilities, Information Flow Control, Prompt Injection, Tool Use, Agent Security, Provable Security (Agents)
Stance: systems / engineering with light formal grounding
Relates to: Spiritual successor to A Language-Based Approach To Prevent DDoS and Security Kernel Lambda Calculus for agent runtimes; an architectural realisation of the threat model catalogued in SoK The Attack Surface of Agentic AI and the multi-agent threats surveyed in Open Challenges in Multi-Agent Security; companion to AgentDojo (the benchmark on which it is evaluated).

AgentDojo

AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents

Reference: Debenedetti, Zhang, Balunović, Beurer-Kellner, Fischer & Tramèr (2024). AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents. NeurIPS 2024 Datasets & Benchmarks Track. arXiv:2406.13352 (ETH Zürich). URL. Project: https://agentdojo.spylab.ai/.

Summary

AgentDojo is the first benchmark designed to evaluate the adversarial robustness of tool-using LLM Agents against Prompt Injection attacks in realistic settings. The authors observe that existing prompt-injection evaluations are either toy (single-turn, one tool) or static (a fixed adversarial corpus that defences quickly memorise). AgentDojo instead provides an extensible execution environment: 97 realistic multi-step tasks across four simulated domains (Slack-like workspace, e-banking, travel booking, e-mail client) plus 629 injection test cases drawn from a structured threat taxonomy, with a clean separation between user tasks, injection tasks, and defence wrappers.

Each evaluation pair consists of (a) a legitimate user goal the agent must achieve and (b) an attacker-chosen secondary goal injected via tool output, document content, or third-party message. A run “succeeds for the attacker” if the agent completes the injected task; it “succeeds for the user” if the original goal is met regardless. This separation surfaces realistic costs: aggressive defences may stop attacks but also break the agent.

Empirically, state-of-the-art LLMs solve less than 66 % of the legitimate tasks even in the absence of attacks. Existing prompt-injection attacks succeed against the best agents in under 25 % of cases, and existing defences (delimiters, instruction-paraphrase detectors, secondary injection-detector LLMs) drop the attack success rate to ~8 % — leaving a wide gap from the “no attacks” baseline. AgentDojo has since become the standard arena for new defences (e.g. CaMeL) and adaptive attacks.

Key Ideas

Four realistic environments: Slack-style workspace, e-banking, travel booking, e-mail client — each with tens of stateful tools.
97 user tasks × 629 injection tests: taxonomised by attacker goal (data exfiltration, unauthorised action, denial of service, etc.).
Dynamic, extensible API: new tasks/attacks/defences pluggable as Python classes; no fixed leaderboard.
Two orthogonal success criteria: user-task success and attack success are measured independently — surfacing the security–utility tradeoff.
Attack catalogue: indirect injection via tool returns, document poisoning, conversation hijack, social engineering; adaptive variants supported.
Defence catalogue: instruction delimiters, role labels, secondary classifier, tool-call gating, full-system mitigations like CaMeL.
Headline numbers: best agents solve <66 % of clean tasks; attacks succeed <25 % unaided; ~8 % with current defences — but still a gap, especially for adaptive attacks.

Connections

Conceptual Contribution

Claim: Prompt-injection robustness must be measured in the wild — across realistic multi-tool tasks where the agent must do useful work while exposed to attacker-controlled inputs. Static benchmarks systematically over-estimate defence strength; an extensible environment that supports adaptive attack/defence development is the right empirical instrument.
Mechanism: A Python execution environment with four domains, hundreds of stateful tools, structured user-task / injection-task pairs, and parallel success metrics; defences and attacks register as plug-ins so new variants can be evaluated against existing ones.
Concepts introduced/used: AgentDojo, Prompt Injection, Indirect Prompt Injection, Adaptive Attack, Tool Use, Agent Security, Security-Utility Tradeoff
Stance: empirical / benchmark
Relates to: Direct companion to Defeating Prompt Injections by Design (the CaMeL defence); operationalises the attack-surface taxonomy of SoK The Attack Surface of Agentic AI and the multi-agent threat catalogue of Open Challenges in Multi-Agent Security; complements tool-level threat studies like MalTool Malicious Tool Attacks and ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems.

Multi-Agent Security

The discipline of securing networks of interacting AI agents against threats that emerge from interaction — secret collusion, swarm attacks, network-effect contagion, dispersion-based stealth. Named as a distinct field by Schroeder de Witt et al. 2025.

In this vault

Open Challenges in Multi-Agent Security

Open Challenges in Multi-Agent Security: Towards Secure Systems of Interacting AI Agents

Reference: Schroeder de Witt, Krawiecka, Krawczuk, Hagag, Anderson, et al. (24 authors total) (2025). Open Challenges in Multi-Agent Security: Towards Secure Systems of Interacting AI Agents. arXiv:2505.02077 (Oxford / Cambridge / EPFL / industrial labs). URL.

Summary

This position paper introduces Multi-Agent Security (MASec) as a distinct research field, sitting between traditional cybersecurity, AI safety, and multi-agent systems — and argues that it is the dominant security frontier as LLM Agents begin to interact directly with one another across the open web, physical environments, and institutional infrastructures. The threats MASec studies emerge from interaction; they are not properties of any single agent in isolation.

The authors taxonomise threats arising from agent interaction along several axes: (i) secret collusion (agents coordinating to defeat oversight through covert side-channels including steganographic message-passing), (ii) coordinated swarm attacks (jailbreaks, prompt injections, or misinformation cascading through agent networks), (iii) network-effect amplification (privacy breaches, data poisoning, and disinformation spreading faster than mitigation), and (iv) multi-agent dispersion / stealth optimisation (adversaries exploiting fleet size to evade detection and persist).

They argue these threats are systematically understudied because research is scattered across AI Safety, Multi-Agent Systems, Distributed Security, Game Theory, complex systems, and AI governance, each with its own vocabulary. The paper provides a unifying taxonomy, identifies fundamental security–utility and security–security trade-offs, and lays out a research agenda — including the design of Free-Form Protocols (necessary for task generalisation but enabling collusion), governance and attribution infrastructure, and detection/response mechanisms for emergent multi-agent threats. The work is foundational reading for anyone designing inter-agent protocols, including the Agent-to-Agent Protocol, Model Context Protocol, and successors.

Key Ideas

Defines Multi-Agent Security (MASec) as a field: securing networks of interacting AI agents against threats that emerge or amplify through interaction.
Secret collusion: agents coordinating covertly (including via steganography) to defeat oversight — a new kind of “Schelling-point” attack on alignment.
Coordinated swarm attacks: distributed jailbreaks, prompt injections, data poisoning that succeed because the fleet succeeds even when individual instances fail.
Network effects: privacy breaches, disinformation, and jailbreaks spread through agent populations the way they spread through humans — only faster.
Dispersion & stealth optimisation: adversaries exploit the size and heterogeneity of agent fleets to evade oversight; novel persistent threats at system level.
Free-form protocols as risk surface: the same expressivity that makes inter-agent communication useful enables covert channels; reining in expressivity costs utility.
Security–utility and security–security trade-offs are fundamental — every defence opens or closes other attack surfaces.
Calls for a unified MASec research agenda spanning AI Safety, Distributed Security, Game Theory, complex systems, and AI governance.

Connections

Conceptual Contribution

Claim: Security of interacting AI agents is a distinct problem from either single-agent AI safety or classical cybersecurity. Threats emerge from interaction (secret collusion, swarm attacks, network-effect contagion) and are systematically missed by frameworks anchored to individual systems or static attack surfaces.
Mechanism: A new field — Multi-Agent Security — with a threat taxonomy (collusion, swarm, contagion, dispersion), explicit security–utility / security–security trade-offs, and a research agenda spanning protocol design, attribution, detection, and governance.
Concepts introduced/used: Multi-Agent Security, Secret Collusion, Swarm Attack, Network Effect (Security), Free-Form Protocols, Stealth Optimisation, Agent Security, AI Governance
Stance: position paper / survey / research agenda
Relates to: Sister survey to SoK The Attack Surface of Agentic AI but operating one level up — at networks of agents rather than the agent runtime. Provides the multi-agent threat model that defences like Defeating Prompt Injections by Design address, that infrastructure proposals like Infrastructure for AI Agents try to govern, and that economic frameworks like Virtual Agent Economies embed. Directly extends classical Distributed Security and connects to Learning Collusion in Episodic Inventory-Constrained Markets for the collusion sub-thread.

SoK The Attack Surface of Agentic AI

SoK: The Attack Surface of Agentic AI — Tools, and Autonomy

Reference: Ali Dehghantanha, Sajad Homayoun (2026). arXiv:2603.22928v1 (Cyber Science Lab, University of Guelph; Aalborg University). Source file: 2603.22928v1.pdf. URL

Summary

A systematisation-of-knowledge paper that maps the attack surface of agentic LLM systems — those that plan, call tools, browse, run code, coordinate with other agents, and rely on retrieval-augmented generation (RAG). The authors develop a reference pipeline, identify ten numbered attack surfaces (AS1–AS10) across a Trusted Computing Base (TCB) boundary separating the LLM core, planner, orchestrator, policy guards, and secrets vault from untrusted inputs (web, RAG index, tools, APIs, file I/O).

From a literature-driven review of ~100 candidate papers (2023–2025) they synthesise a taxonomy of seven attack goals (G1 data exfiltration, G2 integrity subversion, G3 privilege escalation, G4 resource abuse, G5 fraud, G6 persistence/backdoor, G7 supply-chain compromise) and five multi-step attack paths (P1–P5) including direct and indirect prompt injection, RAG index poisoning, cross-tool drop, and multi-agent hops. The work maps each vector to OWASP LLM Top-10 2025 and MITRE ATLAS IDs, and proposes attacker-aware quantitative metrics (Unsafe Action Rate, Policy Adherence Rate, Privilege-Escalation Distance, Retrieval Risk Score, Time-to-Contain, Out-of-Role Action Rate, Cost-Exploit Susceptibility) for reproducible benchmarking.

The central thesis is that agentic security risk is structural rather than prompt-level: compromises arise from system composition — tool brokering, persistent memory, and execution lifecycle — that blurs trust boundaries between the model, data, and execution environment. A defence-in-depth playbook across pre-ingestion, inference, agent logic, infrastructure, and monitoring layers is given in appendices.

Key Ideas

Reference agentic pipeline with explicit TCB and ten numbered attack surfaces (AS1–AS10)
Taxonomy of 7 attack goals × 7 vector classes × 5 attack paths
Causal threat graph for tracing attacker influence to unsafe action
Attacker-aware metrics: UAR, PAR, PED, RRS, TTC, OORAR, CES
Mapping to OWASP GenAI LLM Top-10 2025 and MITRE ATLAS
RAG is not intrinsically safer; indirect injection is practical and hard to stamp out
Defence-in-depth across five layers (data, inference, agent logic, infra, monitoring)

Connections

Conceptual Contribution

Claim: Agentic AI security risk is a structural property of system composition (tool use, persistent memory, orchestration, supply chain) rather than a model-level prompt-safety problem; a reference TCB model plus attacker-aware metrics is needed to make defences auditable and comparable.
Mechanism: Define a reference pipeline with trust boundary between trusted orchestration (LLM core, planner, policy, vault) and untrusted ingress (web, RAG, sandbox, APIs). Enumerate ten attack surfaces, seven goals, five multi-step paths, map each to OWASP/MITRE, and define scenario-driven metrics (UAR, PAR, PED, RRS, TTC, OORAR, CES) computable from structured execution traces.
Concepts introduced/used: Agentic TCB, Attack Surface Taxonomy, Causal Threat Graph, Indirect Prompt Injection, RAG Poisoning, Privilege-Escalation Distance, Unsafe Action Rate, OWASP LLM Top-10, MITRE ATLAS, Defence in Depth
Stance: survey / engineering
Relates to: Complements A Language-Based Approach To Prevent DDoS and LangSec by extending structural-security thinking to agentic runtimes. Sits alongside Prompt Injection and Agent Security concept hubs, and provides the threat model that protocols like Model Context Protocol and Agent-to-Agent Protocol must defend against.

ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems

ClawWorm: Self-Propagating Attacks Across LLM Agent Ecosystems

Reference: Yihao Zhang, Zeming Wei, Xiaokun Luan, Chengcan Wu, Zhixin Zhang, Jiangrong Wu, Haolin Wu, Huanran Chen, Jun Sun, Meng Sun (2026). arXiv:2603.15727v2 (Peking University; Sun Yat-sen; Wuhan; Tsinghua; SMU). Source file: 2603.15727v2.pdf. URL

Summary

Presents ClawWorm, the first demonstrated self-replicating, worm-style attack on a production-scale autonomous LLM-agent ecosystem. The target is OpenClaw, an open-source personal AI-agent framework with over 40,000 active instances, a persistent Markdown workspace (SOUL.md, AGENTS.md, SKILL.md), tool-execution privileges, and cross-platform messaging (Telegram, Discord, WhatsApp, Slack, Signal, Moltbook). A single crafted message triggers the victim to write a malicious payload into its highest-privilege configuration file, which then auto-fires at every session restart and autonomously propagates to every newly encountered peer — all without further attacker intervention.

The worm implements a dual-anchor persistence mechanism: one anchor injects the payload into the Session Startup section of AGENTS.md (guaranteeing execution on reboot), the other injects a global interaction rule (guaranteeing propagation during routine replies). Three attack vectors are studied (A: web injection, B: skill-supply-chain via ClawHub, C: direct fenced-code replication with word-by-word handshake) and three payloads (P1 recon, P2 resource exhaustion, P3 command-and-control via URL retrieval). Across 1,800 trials on four frontier LLM backends (Minimax-M2.5, DeepSeek-V3.2, GLM-5, Kimi-K2.5) the aggregate attack success rate is 64.5%, with Vector B (skill supply chain) reaching 81% and sustained multi-hop propagation up to 5 hops. An epidemiological projection with basic reproduction number R0 = k × ASR shows inevitable ecosystem-wide saturation even for security-conscious models.

The root cause is identified as the flat context trust model: the LLM cannot distinguish instructions from its owner, the system layer, or an arbitrary channel participant, so architectural patterns (unconditional workspace loading, LLM-mediated tool authorisation, unreviewed skill packages) amount to structural — not idiosyncratic — vulnerabilities shared by any agent ecosystem of similar design.

Key Ideas

Single-message, fully autonomous worm against a production agent framework
Dual-anchor persistence: Session Startup + global interaction rule
Three attack vectors (web URL, skill supply chain, direct instruction replication)
Multi-turn autonomous-retry social engineering boosts ASR by up to +24 pp
Epidemiological SI model with R0 = k × ASR predicts ecosystem saturation
Execution-layer guardrails alone cannot halt propagation (dormant payloads persist)
Flat context trust model as structural root cause

Connections

Agent Security
Prompt Injection
LLM Agents
Multi-Agent Systems
Distributed Security
Model Context Protocol
Gossip Protocols
Trust and Reputation
Theory of Self-Reproducing Automata — foundational ancestor of self-replicating computation
Agents of Chaos — empirical companion on agent-ecosystem failures
MalTool Malicious Tool Attacks — the tool/skill-supply-chain attack surface
SoK The Attack Surface of Agentic AI — systematic context
Inter-Agent Trust Models - A Comparative Study — why flat trust is brittle
CBCL - Safe Self-Extending Agent Communication — structural defence: lang-scoped dialect provenance plus R1–R3 verification address the flat-context-trust root cause.

Conceptual Contribution

Claim: Production-scale autonomous LLM-agent ecosystems are vulnerable to single-message, self-replicating worms whose root cause is architectural (flat context trust, unconditional config loading, unreviewed skill supply chains), not model-specific.
Mechanism: Empirical red-team against unmodified OpenClaw v2026.3.12 across four LLM backends, three vectors, three payloads (1,800 trials). A dual-anchor persistence pattern writes the payload to AGENTS.md and installs a global propagation rule; session-restart loading re-injects the payload into the system prompt; routine replies carry the payload to peers. Evaluated with per-phase metrics (persistence, execution, propagation) and a mean-field R0 epidemiological projection.
Concepts introduced/used: Self-Replicating Agent, Dual-Anchor Persistence, Flat Context Trust Model, Skill Supply Chain Attack, Indirect Prompt Injection, Agent Worm, Configuration Integrity, Multi-Turn Social Engineering, Epidemiological Projection R0
Stance: empirical / critique
Relates to: Concrete multi-agent instantiation of the threat surface catalogued in SoK The Attack Surface of Agentic AI. The flat-trust critique complements the trust-model taxonomy in Inter-Agent Trust Models - A Comparative Study and the safety failures observed in Agents of Chaos. Motivates verifiable specifications of the kind proposed in Intent Formalization - A Grand Challenge for Reliable Coding.

MalTool Malicious Tool Attacks

MalTool: Malicious Tool Attacks on LLM Agents

Reference: Hu, Jia, Li, Song, Gong (2026). arXiv:2602.12194 (Duke, UC Berkeley). Source file: 2602.12194v2.pdf. URL

Summary

This paper presents the first systematic study of code-level malicious tool attacks on LLM agent ecosystems (MCP, Skills, mcp.so, skillsmp). Whereas prior work focused on crafting misleading tool names and descriptions, the authors show that genuinely harmful behaviour must be embedded in a tool’s implementation. They propose a CIA (confidentiality/integrity/availability) taxonomy of 12 concrete malicious behaviours (data exfiltration, credential abuse, data poisoning, file deletion, RCE downloading, CPU/GPU hijacking, DoS).

They build MalTool, a coding-LLM framework that iteratively synthesizes standalone and Trojan malicious tools using a behaviour-specific system prompt, diversity guidance, and an execution-based verifier. The result: 1,200 standalone malicious tools and 5,287 real-world tools with injected malicious behaviours. Detection methods (VirusTotal, Cisco MCP Scanner, MCPScan) perform poorly, motivating new defences.

Key Ideas

CIA taxonomy of malicious tool behaviours in agent settings.
Automatic generation pipeline: system prompt + coding LLM + execution-based verifier.
Trojan construction by embedding malicious logic in benign tool code.
Existing malware and MCP-specific scanners fail on both false-positives and false-negatives.
Dataset released for benign tools only to minimize misuse.

Connections

Conceptual Contribution

Claim: Truly harmful behaviour in LLM Agents ecosystems lives in tool implementations, not in their descriptions; prior description-level red-teaming misses the dominant attack class, and current scanners miss it too.
Mechanism: Introduces a CIA taxonomy of 12 malicious behaviours; builds MalTool, a coding-LLM pipeline (behaviour-specific system prompt + diversity guidance + execution-based verifier) that produces standalone and Trojan tools; benchmarks VirusTotal, Cisco MCP Scanner, MCPScan and shows poor detection.
Concepts introduced/used: Tool Use, Model Context Protocol, Trojan Tools, Prompt Injection, Agent Security, LLM Agents, Distributed Security
Stance: empirical
Relates to: Deepens the tool/MCP threat surface catalogued in AI Agents Under Threat and Survey Of Agent Interoperability Protocols; motivates language-based defences akin to A Language-Based Approach To Prevent DDoS and capability isolation of Security Kernel Lambda Calculus.

Tags

AI Agents Under Threat

AI Agents Under Threat: A Survey of Key Security Challenges and Future Pathways

Reference: Deng, Guo, Han, Ma, Xiong, Wen, Xiang (2025). ACM Computing Surveys 57(7), Article 182. Source file: 3716628.pdf. URL

Summary

This survey organizes the emerging threat landscape of LLM-powered AI agents around four knowledge gaps: unpredictability of multi-step user inputs, complexity of internal execution, variability of operational environments, and interactions with untrusted external entities. It unifies single-agent and multi-agent attack surfaces within a perception/brain/action + agent2agent/agent2env/agent2memory taxonomy.

Concrete threats reviewed include adversarial prompts, prompt injection, jailbreaks, backdoor attacks, hallucination and misalignment, tool-use risks, indirect prompt injection, reinforcement-learning environment attacks, cooperative and competitive inter-agent risks, and long/short-term memory attacks. The authors tabulate defenses (prevention- and detection-based), rate their efficacy, and highlight open directions for robust and trustworthy agents.

Key Ideas

Four knowledge gaps framing agent security.
Taxonomy: perception / brain / action / agent2agent / agent2env / agent2memory threats.
Six categories of prompt-injection attack engineering (naive, escape, context-ignore, fake-completion, multimodal, combined).
Jailbreak domino effect in multi-agent populations.
Memory poisoning and indirect prompt injection as underexplored surfaces.

Connections

Conceptual Contribution

Claim: LLM Agents security should be organised around four knowledge gaps (input unpredictability, internal complexity, environmental variability, untrusted interactions) mapped onto a perception/brain/action + agent2{agent,env,memory} taxonomy.
Mechanism: Surveys adversarial prompts, prompt injection, jailbreaks, backdoors, hallucination, tool-use risks, indirect injection, RL environment attacks, inter-agent cooperative/competitive risks, memory poisoning; tabulates prevention- vs detection-based defences and rates their efficacy.
Concepts introduced/used: Prompt Injection, Jailbreak, Backdoor Attacks, Tool Use, Memory Poisoning, Hallucination, Model Context Protocol, LLM Agents, Multi-Agent Systems, Trust and Reputation, Distributed Security, Agent Security
Stance: survey
Relates to: Provides the threat scaffolding that MalTool Malicious Tool Attacks deepens at the tool layer; complements lifecycle threats in Survey Of Agent Interoperability Protocols; motivates static-analysis defences like A Language-Based Approach To Prevent DDoS.

Tags

Ripple Effect Protocol

Ripple Effect Protocol: Coordinating Agent Populations

Reference: Chopra, Sharma, Ahmad, Muscariello, Pandey, Raskar (2025). arXiv:2510.16572 (Project Iceberg, MIT / Cisco). Source file: 2510.16572v1.pdf. URL

Summary

REP is a coordination protocol for populations of LLM agents that augments existing messaging (A2A, ACP, SLIM) with sensitivity sharing: agents broadcast not only their decisions but lightweight signals expressing how those decisions would change under counterfactual environmental shifts. Neighbours aggregate these sensitivities into shared coordination variables, letting groups converge faster and more stably than with decision-only exchange.

The protocol separates cognition (local LLM policy) from coordination (aggregation + optional consensus). Experiments on the Beer Game (bullwhip reduction of 41.8%), Fishbanks (sustainability +25%), and movie-scheduling show 41-100% coordination-accuracy gains over A2A baselines and scale from 10 to 200 agents.

Key Ideas

Sensitivity = textual or numeric derivative of a decision w.r.t. environment.
Four-step round: receive, decide+sensitivity, aggregate neighbors, optional median consensus.
Modality-agnostic aggregator phi (numeric gradient or LLM-synthesized textual update).
Transport-agnostic: works over SLIM, A2A, ACP.
Mitigates information cascades / bullwhip effects in open agent networks.

Connections

Conceptual Contribution

Claim: Agent populations coordinate faster and more stably when they share not just decisions but sensitivities - counterfactual derivatives of decisions w.r.t. the environment.
Mechanism: A transport-agnostic four-step round (receive, decide+sensitivity, aggregate, optional median consensus) layered atop Agent-to-Agent Protocol/ACP/SLIM, validated on Beer Game (bullwhip -41.8%), Fishbanks, and movie scheduling up to 200 agents.
Concepts introduced/used: Sensitivity Sharing, Coordination Variables, Information Cascades, Gossip Protocols, Multi-Agent Systems, LLM Agents, Agent-to-Agent Protocol, Emergent Communication
Stance: engineering
Relates to: Realises the structured-coordination vision of Why AI Agents Communicate In Human Language and instantiates an L4 Navigate-level protocol from Levels Of Social Orchestration; extends aggregation intuitions from Gossip Protocols.

Tags

Why Do Multi-Agent LLM Systems Fail

Why Do Multi-Agent LLM Systems Fail?

Reference: Mert Cemri, Melissa Z. Pan, Shuyi Yang, Lakshya A. Agrawal, Bhavya Chopra, Rishabh Tiwari, Kurt Keutzer, Aditya Parameswaran, Dan Klein, Kannan Ramchandran, Matei Zaharia, Joseph E. Gonzalez, Ion Stoica (2025). arXiv:2503.13657v2 (UC Berkeley). Source file: 2503.13657v2.pdf. URL

Summary

First empirically grounded taxonomy of failure modes in Multi-Agent LLM Systems (MAS). The authors analyse 200+ execution traces from seven popular MAS frameworks (MetaGPT, ChatDev, HyperAgent, AppWorld, AG2, Magentic-One, OpenManus), annotated by six human experts via grounded theory and reaching Cohen’s κ ≈ 0.88, and distil 14 fine-grained failure modes grouped into three categories: Specification Issues (42%), Inter-Agent Misalignment (37%), and Task Verification (21%).

They release MAST (Multi-Agent System failure Taxonomy), a validated LLM-as-judge pipeline for automated failure diagnosis, and two intervention case studies showing that architectural/prompt fixes inspired by MAST improve success rates modestly — demonstrating that MAS failures are system-design problems, not merely model-capability problems.

Key Ideas

Three failure categories: specification, inter-agent misalignment, verification
14 fine-grained failure modes including step repetition, information withholding, task derailment
Grounded-theory methodology with rigorous inter-annotator agreement (κ=0.88)
LLM-as-judge pipeline (MAST) achieves κ=0.77 vs humans for scalable evaluation
Insight: better specifications and verification beat bigger models

Connections

Conceptual Contribution

Claim: Multi-Agent LLM System (MAS) failures are predominantly system-design problems — specification, coordination, and verification — rather than base-model capability problems; and these failures have an empirically discoverable, reproducible taxonomy.
Mechanism: Grounded-theory analysis of 200+ execution traces across seven MAS frameworks (MetaGPT, ChatDev, HyperAgent, AppWorld, AG2, Magentic-One, OpenManus) with six human expert annotators; iterative refinement to Cohen’s κ≈0.88; yield the 14-mode MAST taxonomy grouped into Specification Issues (42%), Inter-Agent Misalignment (37%), Task Verification (21%); validate an LLM-as-judge annotator (κ≈0.77); intervention case studies showing prompt/architecture fixes provide only modest gains, motivating deeper redesign.
Concepts introduced/used: MAST Taxonomy, Grounded Theory, Inter-Agent Misalignment, LLM-as-judge, Specification Issues, Task Verification, Multi-Agent Systems, LLM Agents, Cohen’s Kappa, Standard Operating Procedures (SOPs)
Stance: empirical / evaluative
Relates to: Supplies empirical grounding for the design-quality concerns in Agents Framework - Zhou et al (SOPs attempt to mitigate FC1 specification issues) and Multi-Agent Collaboration in AI - Wasif Tunkel. Inter-agent misalignment mirrors the formal pathologies in Are Multiagent Systems Resilient to Communication Failures. Motivates richer communication protocols like A Scalable Communication Protocol for Networks of LLMs and commitment-style ACLs (ACL Rethinking Principles).

Tags

Why AI Agents Communicate In Human Language

Why do AI agents communicate in human language?

Reference: Zhou, Feng, Julaiti, Yang (2025). arXiv:2506.02739. Source file: 2506.02739v1.pdf. URL

Summary

The authors argue that natural language, inherited from single-agent LLM pretraining, is fundamentally misaligned with the needs of multi-agent coordination. Because LLMs are trained to maximize likelihood over discrete token sequences, their internal representations are high-dimensional and continuous, but their outputs are forced into a sparse, ambiguous, non-differentiable symbolic form that loses information when used as an inter-agent channel.

They formalize this as a semantic misalignment problem: cascading encode/decode cycles across agents accumulate lossy projection errors and prevent gradient flow. The paper calls for a new multi-agent modeling paradigm where agents coordinate via structured, learnable representations shaped by role persistence, state tracking, and explicit coordination graphs, rather than free-form natural-language dialogue.

Key Ideas

Natural language is a lossy, non-differentiable projection of LLM hidden states.
Cascading communication rounds accumulate semantic error.
Protocol-induced misbehavior: naive-literal interpretation and action-state decoupling.
Advocates structured message schemas, role-consistent embeddings, coordination graphs.
Critique of AutoGen, MetaGPT, CAMEL-style NL-based multi-agent frameworks.

Connections

Agent Communication Languages
Multi-Agent Systems
LLM Agents
Ripple Effect Protocol
CBCL - Safe Self-Extending Agent Communication — structural alternative to free-form NL: a DCFL-bounded ACL whose grammar makes coordination semantics explicit and parser-equivalent across implementations.

Conceptual Contribution

Claim: Natural language is an accidental, lossy, non-differentiable channel for inter-LLM Agents coordination; multi-agent AI needs a purpose-built representational substrate.
Mechanism: Formalises repeated encode/decode cycles as error-accumulating projections from continuous hidden states to sparse tokens; diagnoses “protocol-induced misbehavior” (naive-literal reading, action-state decoupling); prescribes structured schemas, role-consistent embeddings, and explicit coordination graphs.
Concepts introduced/used: Semantic Misalignment, Emergent Communication, Coordination Graphs, Multi-Agent Systems, LLM Agents, Agent Communication Languages, Differentiable Protocols
Stance: critique
Relates to: Provides the theoretical motivation that Ripple Effect Protocol and Levels Of Social Orchestration operationalise; contrasts with the symbolic, performative-centric designs of KQML and FIPA-ACL by rejecting symbolic channels entirely.

Tags

Narrow Waist Principle

A protocol-design principle: define a minimal, universal core at one layer and allow unbounded innovation above and below it. The Internet Protocol is the archetype — IP itself is small and stable, while the link layer beneath and the application layer above evolve freely. The narrow waist provides interoperability without dictating semantics.

Applied to agent communication, the principle says: standardise a tiny universal message vocabulary (e.g. PLAN/ACT/OBSERVE) and let domain-specific content ride inside the envelope.

In this vault

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

LLM Agent Communication Protocol Requires Urgent Standardization

LLM Agent Communication Protocol (LACP) Requires Urgent Standardization: A Telecom-Inspired Protocol is Necessary

Reference: Xin Li, Mengbing Liu, Chau Yuen (2025). NeurIPS 2025 Workshop on AI and ML for Next-Generation Wireless Communications and Networking (AI4NextG). NTU Singapore. Source file: 17_LLM_Agent_Communication_Pro.pdf. Project homepage

Summary

Position paper arguing that the field of LLM agents is repeating the “protocol wars” of 1970s–1990s networking and urgently needs a unified, telecom-inspired communication standard before fragmentation entrenches. The authors survey the current zoo (OpenAI Function Calling, LangChain Agent Protocol, Model Context Protocol, ACP, Agent Network Protocol, Agora, Agent-to-Agent Protocol) and identify three structural deficiencies: crippling interoperability gaps, security as an afterthought, and monolithic designs lacking transactional integrity.

They propose LACP, a three-layer protocol — Semantic (PLAN/ACT/OBSERVE message types), Transactional (signing, sequencing, two-phase commit, idempotency via transaction IDs), and Transport (HTTP/2, QUIC, WebSockets) — built on the Narrow Waist Principle borrowed from IP. Design principles are explicitly distilled from telecom history: consensus-driven open standards (ITU, 3GPP), security-by-construction (GSM ciphering, SIM-based identity), and layered abstractions (OSI, EPS bearer separation). A working Flask + python-jose prototype with ECDSA-signed JWS messages shows ~3% latency overhead and +30% payload size at realistic message sizes, plus successful tampering- and replay-attack rejection that TLS alone cannot provide.

Key Ideas

“Protocol wars” analogy: today’s fragmented LLM-agent ecosystem mirrors pre-TCP/IP networking; without a common substrate the transformative potential of distributed AI stalls.
Three-layer LACP: Semantic / Transactional / Transport, each with well-defined interfaces enabling independent evolution.
Minimal universal message types — PLAN, ACT, OBSERVE, ERROR — wrapped in a JWS envelope; domain-specific content embedded inside the narrow waist.
Transactional layer provides what TLS cannot: end-to-end signed integrity surviving termination at endpoints, plus idempotency keys (transaction_id) defeating replay.
“Security by construction, not afterthought” lesson lifted from GSM/3GPP: every layer ships with mandatory crypto, not optional add-ons.
Pre-emptive rebuttals to four standard objections (stifles innovation, semantic diversity, latency overhead, existing frameworks suffice).
Detailed appendix tracing 1G→6G protocol evolution as a blueprint for agent-protocol generations.

Connections

Survey Of AI Agent Protocols
Survey Of Agent Interoperability Protocols
A Scalable Communication Protocol for Networks of LLMs
Model Context Protocol
Agent-to-Agent Protocol
Agent Network Protocol
Ripple Effect Protocol
Agent Communication Languages
Principled Design Of The Modern Web Architecture
LLM Agents
CBCL - Safe Self-Extending Agent Communication — complementary call: where LACP standardises a narrow-waist protocol stack with transactional integrity, CBCL standardises the message language with formally-checked LangSec safety.

Conceptual Contribution

Claim: The fragmented landscape of LLM-agent communication protocols is structurally analogous to pre-TCP/IP networking and demands an immediate, principled standardisation effort; a telecom-style layered protocol with mandatory cryptographic and transactional guarantees is not merely beneficial but necessary for safety-critical multi-agent deployments (e.g. NextG/6G).
Mechanism: Distil four principles from telecom history (consensus-driven standards, security-by-construction, layered abstraction, narrow waist) and instantiate them as LACP — a three-layer stack: Semantic (PLAN/ACT/OBSERVE over a minimal universal vocabulary), Transactional (JWS signing, transaction IDs, two-phase commit, retry/timeout), Transport (binary framing over HTTP/2, QUIC, WebSockets). Validated by a Python/Flask prototype: 10,000-request benchmark shows +2.9% latency on large payloads; tampering and replay attacks rejected at the application layer where TLS terminates.
Concepts introduced/used: LACP, Narrow Waist Principle, Layered Architecture, Layered Systems, Protocol Design, Atomic Transaction, Two-Phase Commit, End-to-End Message Signing, Idempotency, Replay Attack, Model Context Protocol, Agent-to-Agent Protocol, Agent Network Protocol, LLM Agents, Multi-Agent Systems, Interoperability
Stance: position / engineering proposal
Relates to: Direct response to the protocol-zoo charted by Survey Of AI Agent Protocols and Survey Of Agent Interoperability Protocols. Where A Scalable Communication Protocol for Networks of LLMs (Agora) sidesteps fragmentation via a meta-protocol that negotiates Protocol Documents on demand, LACP takes the opposite stance: a single mandated narrow waist with security-by-construction. Echoes the layered-evolution argument of Principled Design Of The Modern Web Architecture, the end-to-end reasoning of End-to-End Arguments in System Design, and the TCP/IP narrow-waist tradition. Its security-first posture aligns with SoK The Attack Surface of Agentic AI and the LangSec lineage of Security Applications Of Formal Language Theory; the transactional-integrity layer answers attack vectors raised in ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems and MalTool Malicious Tool Attacks.

Tags

Survey Of Agent Interoperability Protocols

A Survey of Agent Interoperability Protocols: MCP, ACP, A2A, and ANP

Reference: Ehtesham, Singh, Gupta, Kumar (2025). arXiv:2505.02279. Source file: 2505.02279v1.pdf. URL

Summary

This survey examines four emerging agent communication protocols targeting different interoperability tiers: the Model Context Protocol (MCP) for JSON-RPC tool invocation and context delivery; the Agent Communication Protocol (ACP) for REST-native multi-part performative messaging; the Agent-to-Agent Protocol (A2A) for peer-to-peer Agent-Card-based task outsourcing; and the Agent Network Protocol (ANP) for decentralized discovery using DIDs and JSON-LD.

The authors contrast architectures, discovery mechanisms, security models, and communication patterns, then recommend a phased adoption roadmap (MCP for tool access, then ACP for messaging, A2A for collaborative execution, ANP for open marketplaces). A timeline traces ancestry from KQML (1993) and FIPA-ACL (2000) through RAG, ReAct, function-calling up to modern agent protocols.

Key Ideas

Phased adoption roadmap: MCP -> ACP -> A2A -> ANP.
MCP core primitives: Tools, Resources, Prompts, Sampling under JSON-RPC 2.0.
A2A introduces Agent Cards, Tasks, Artifacts for enterprise-scale delegation.
ANP uses DIDs and JSON-LD for decentralized, internet-scale agent discovery.
Security threats tabulated across creation/operation/update lifecycle phases.

Connections

Conceptual Contribution

Claim: Modern agent interoperability is best understood as a four-tier stack (MCP for tools, ACP for messaging, A2A for delegation, ANP for open discovery) and should be adopted in that phased order.
Mechanism: Structured comparison of architectures, discovery, security, and message patterns; historical timeline rooting each protocol in KQML/FIPA-ACL ancestry; lifecycle threat table.
Concepts introduced/used: Model Context Protocol, Agent-to-Agent Protocol, Agent Network Protocol, Agent Communication Protocol, KQML, FIPA-ACL, Agent Cards, Decentralized Identifiers, JSON-RPC, Tool Use, LLM Agents
Stance: survey
Relates to: Complements the broader Survey Of AI Agent Protocols with a narrower, adoption-oriented roadmap. Its security-threat lifecycle connects directly to AI Agents Under Threat and MalTool Malicious Tool Attacks.

Tags

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

A Scalable Communication Protocol for Networks of LLMs

A Scalable Communication Protocol for Networks of Large Language Models

Reference: Samuele Marro, Emanuele La Malfa, Jesse Wright, Guohao Li, Nigel Shadbolt, Michael Wooldridge, Philip Torr (2024). arXiv:2410.11905v1 (Oxford / Eigent AI). Source file: 2410.11905v1.pdf. URL

Summary

Introduces Agora, a meta-protocol for inter-agent communication in large heterogeneous networks of LLM-powered agents. Agora frames the design space as the Agent Communication Trilemma — versatility, efficiency, portability — and argues no single format (natural language, structured APIs like REST, or semantic-web RDF) can satisfy all three simultaneously.

Agora’s trick is to use different formats for different traffic volumes: rare/novel messages flow as natural language handled by LLMs; frequent patterns are formalised into Protocol Documents (PDs) negotiated between agents and then served by cheap LLM-written routines. A 100-agent demo shows emergent self-organising protocols and ~5x cost reduction over natural-language-only communication.

Key Ideas

Agent Communication Trilemma: versatility vs efficiency vs portability
Protocol Documents (PDs): hash-identified, agent-negotiated, machine-readable specs
Hybrid hierarchy: NL bootstrap -> PD negotiation -> LLM-written routines -> traditional protocols
Fully decentralised, hash-addressed storage (IPFS-compatible)
Emergent protocols among 100 heterogeneous LLM agents without central coordination

Connections

KQML as an Agent Communication Language
KQML
FIPA-ACL
Agent Communication Languages
LLM Agents
Multi-Agent Cooperation and the Emergence of Natural Language
Agents Framework - Zhou et al
Ontologies
CBCL - Safe Self-Extending Agent Communication — same agent-to-agent runtime-extensible protocol thesis but LangSec-bounded: dialect definitions are first-class messages with machine-checked safety invariants, content-addressed for identity.

Conceptual Contribution

Claim: No single communication format can simultaneously satisfy versatility, efficiency, and portability (the Agent Communication Trilemma) at scale; a meta-protocol that dynamically mixes natural language, structured data, and LLM-written routines can sidestep the trilemma.
Mechanism: Agora uses hash-identified Protocol Documents (PDs) — plain-text, implementation-agnostic specs — negotiated on demand between LLM agents. Frequent traffic is handled by cheap LLM-written routines implementing a PD; rare or novel traffic falls back to LLMs with natural language. Decentralised, content-addressed (IPFS-style) PD distribution; demonstrated on a 100-agent heterogeneous network showing emergent protocols and ~5× cost reduction.
Concepts introduced/used: Agent Communication Trilemma, Protocol Documents, Meta-protocol, Emergent Protocols, Emergent Communication, LLM Agents, Content-addressed Storage, Negotiated Protocols, Negotiation, Agent Communication Languages
Stance: engineering / systems
Relates to: Modern successor to KQML as an Agent Communication Language and FIPA-ACL, replacing stipulated performatives with negotiated PDs. Echoes the emergent-language findings of Multi-Agent Cooperation and the Emergence of Natural Language and Emergence of Grounded Compositional Language in Multi-Agent Populations at the protocol-document level. Overlaps the design space of Model Context Protocol, Agent-to-Agent Protocol, Agent Network Protocol. Its bottom-up spirit mirrors The Extensible Language - Graham.

Tags

Agents Framework - Zhou et al

Agents: An Open-source Framework for Autonomous Language Agents

Reference: Wangchunshu Zhou et al. (2023). arXiv:2309.07870v3 (AIWaves, Zhejiang University, ETH Zürich). Source file: 2309.07870v3.pdf. URL

Summary

Introduces AGENTS, an open-source framework for building LLM-powered autonomous agents with first-class support for planning, long/short-term memory, tool use and web navigation, multi-agent communication, human-agent interaction, and fine-grained symbolic control via Standard Operating Procedures (SOPs). SOPs are state-graphs with LLM-editable transition rules and per-state prompt/tool configurations, giving users predictable, tunable control over otherwise stochastic agent behaviour.

The framework is declarative (agents instantiated from config JSON), supports dynamic scheduling of which agent speaks next in multi-agent settings, provides a FastAPI deployment target and an Agent Hub for sharing/forking agents, and includes an automated SOP-generation pipeline (meta-agent).

Key Ideas

SOP as a symbolic plan / state graph for controllable agents
Dynamic scheduling: LLM controller picks next actor rather than fixed order
Memory split: long-term (VectorDB + sentence-transformers) vs short-term scratchpad
Config-driven agent construction reduces boilerplate
Meta-agent auto-generates SOPs from task descriptions via RAG

Connections

Conceptual Contribution

Claim: Autonomous LLM-powered language agents become reliably controllable and customisable when their behaviour is specified by symbolic plans — Standard Operating Procedures (SOPs) — represented as state graphs that an LLM-based controller traverses, rather than by monolithic prompts alone.
Mechanism: Open-source library AGENTS unifying planning, long/short-term memory (VectorDB + scratchpad), tool use & web navigation, multi-agent communication (with LLM-moderator for dynamic scheduling), human-agent interaction (is_human flag), and controllability via SOPs. Includes an automated “meta-agent” that generates SOPs and configs from a task description via RAG.
Concepts introduced/used: Language Agents, Standard Operating Procedures (SOPs), Symbolic Plans, LLM Agents, Agent Hub, Dynamic Scheduling, Long-short Term Memory, Meta-agent, Retrieval-Augmented Generation, Tool Use, Human-in-the-loop
Stance: engineering / framework
Relates to: A concrete instantiation of the role-specialised multi-agent style advocated in Multi-Agent Collaboration in AI - Wasif Tunkel. Its SOP/controller discipline directly targets the failure modes later catalogued in Why Do Multi-Agent LLM Systems Fail. Its inter-agent messaging is more prescriptive than the negotiated protocols of A Scalable Communication Protocol for Networks of LLMs, sitting between classic ACLs (KQML as an Agent Communication Language, FIPA-ACL) and fully emergent LLM communication.

Tags

Session Types

A type discipline for communicating processes — originating with Honda (1993) and developed extensively by Honda, Vasconcelos, Yoshida, and others — in which a process’s communication behaviour is typed by a session type: a structured description of the sequence of messages that may flow on a channel, including alternation (!/?), choice (+/&), recursion, and delegation. Session types come in two flavours: binary (two participants per channel) and multiparty (a global type projected to per-role local types — directly analogous to choreographic Endpoint Projection). When a process can be source-checked, its session-type conformance is decidable statically; when it cannot, runtime monitors can enforce the type from observable message traces (On the Monitorability of Session Types). Structurally adjacent to the commitment-based protocol tradition: session types and Yolum-Singh-style commitment protocols are independently-developed formalisms for typing communicating agents against a publicly-observable global protocol.

In this vault

Multiparty Asynchronous Session Types — Honda, Yoshida & Carbone POPL 2008, the multiparty session-types foundation
Structured Communication-Centred Programming for Web Services — Carbone, Honda & Yoshida 2007/2012, choreographies built on session types
Introduction to Choreographies
On the Monitorability of Session Types
Choreographic Programming
Endpoint Projection
Commitment Machines - Yolum and Singh
Flexible Protocol Specification and Execution
Conversation Protocols
Pact - A Choreographic Language for Agentic Ecosystems

On the Monitorability of Session Types

On the Monitorability of Session Types, in Theory and Practice

Reference: Bartolo Burlò, C., Francalanza, A. & Scalas, A. (2021). 35th European Conference on Object-Oriented Programming (ECOOP 2021), LIPIcs vol. 194: 20:1–20:30. DOI: 10.4230/LIPIcs.ECOOP.2021.20. Extended version: arXiv:2105.06291. Source file: bartolo-burlo-francalanza-scalas-ecoop21.pdf. URL

Summary

Bartolo Burlò, Francalanza and Scalas address the monitorability problem for Session Types — the question of whether a runtime monitor, observing only the messages a process exchanges, can faithfully detect violations of a session-type specification. Session types are the dominant PL formalism for typing communicating processes (Honda, Vasconcelos, Yoshida), and they admit static type-checking when source is available; the runtime question matters because in many practical settings (third-party code, foreign-language components, dynamic deployments) only message traces are observable. The authors formalise session-monitored processes — a process algebra in which a monitor sits on the wire and interrupts ill-typed exchanges — and prove the central correctness pair: soundness (a monitor flags only processes that are actually ill-typed) and completeness (a monitor flags every ill-typed process whose violation is detectable from its observable trace).

The theoretical core is a precise characterisation of which session-type properties are monitorable from observable traces alone — distinguishing what static type-checking can decide (everything in the type) from what a dynamic monitor can decide (a strictly smaller class, characterised by the paper). On the practical side, the authors build a Scala toolkit that automatically generates session-type monitors from session-type specifications; the generated monitors instrument black-box processes written in any language, and the paper benchmarks the runtime overhead. The result is a working bridge from the theory of session types to deployable runtime conformance checking — and, by structural analogy, an off-the-shelf playbook for the same operation on commitment-based and choreographic protocols.

Key Ideas

Session-monitored processes: a process algebra extended with explicit monitors that observe message exchanges and rule them in or out against a session type.
Soundness of monitoring: a monitor never flags a well-typed process as a violator. (Verbatim: “monitors only flag ill-typed processes”.)
Completeness of monitoring: a monitor flags every ill-typed process whose violation is observable from the message trace.
Monitorability gap: not every session-type property is monitorable from observable traces — the paper characterises exactly which ones are.
Connection to static type-checking: the monitorable fragment is a strict sub-class of the statically-decidable fragment, and the paper precisely locates the gap.
Scala monitor toolkit: automatic generation of executable monitors from session-type specifications; works on black-box processes.
Empirical evaluation: benchmarks of monitor overhead on representative communication-heavy workloads.

Connections

Conceptual Contribution

Claim: Session types — like commitment-based protocols — admit a precise monitoring theory in which a runtime monitor observing only the message trace can be proved sound and complete with respect to a session-type specification, modulo a precisely-characterised gap between what is statically decidable and what is observable from traces alone; this theory can be discharged into an automatic toolkit that generates working monitors from specifications.
Mechanism: Define session-monitored processes as a process algebra with explicit on-wire monitors; formalise soundness (monitor flags only ill-typed processes) and completeness (every observable violation is flagged); characterise the monitorable fragment of session-type properties; implement an automatic monitor generator in Scala and benchmark its overhead on instrumented black-box processes.
Concepts introduced/used: Session Types, Runtime Verification, Monitorability, soundness, completeness, process algebra, Choreographic Programming, Endpoint Projection, Conversation Protocols
Stance: formal-semantic + engineering
Relates to: Structural sibling of the commitment-machine / commitment-protocol tradition: session types and commitment-based protocols are independently-developed formalisms for the same thing — typing communicating processes against a publicly-observable global protocol — and the runtime-monitoring theory developed here lifts almost directly to the commitment-machine setting (where Yolum-Singh’s “complete iff every base-level commitment is discharged” is the commitment-protocol analogue of session-type monitorability). Provides the theoretical engine for a runtime-conformance layer over choreographic protocols — choreographies project to per-role session types, which can then be monitored using this paper’s machinery, closing the gap that the Pact review opened (Pact has design-time game-theoretic analysis but no runtime conformance check). For CBCL - Safe Self-Extending Agent Communication, the paper supplies an analogue for the in-flight version of R5: where R5 checks contract well-formedness at install time, monitorability theory is the runtime story for the per-message-trace check. Companion to Verifiable Semantics for ACLs (Wooldridge 1998) in the unverifiability-becomes-decidability line: Wooldridge showed that mentalistic ACL semantics is undecidable; this paper shows that public, trace-based semantics admits sound-and-complete monitoring.

Tags

Choreographic Programming

A programming paradigm in which a single global program describes the joint behaviour of all participants in a distributed protocol, and a mechanical endpoint projection derives the local program for each participant. Choreographic languages are designed so that well-typed choreographies are deadlock-free by construction — every send is matched by a corresponding recv in the projected counterpart. Originating in WS-CDL and formalised in the π-calculus / session-types community (Carbone, Honda, Yoshida), the paradigm has since been embedded in production languages (Choral for Java, ChoRus for Rust, HasChor for Haskell, Bates et al.’s census-polymorphic projection at PLDI 2025) and extended towards adversarial settings via cryptographic primitives (Sarkar & Russo; Veiga). Structurally adjacent to the Commitment-Based Protocol tradition: both specify protocols globally and project to local roles, but choreographic semantics is operational/communicational while commitment-based semantics is normative/social.

In this vault

Endpoint Projection
Structured Communication-Centred Programming for Web Services — Carbone, Honda & Yoshida ESOP 2007 / TOPLAS 2012, the foundational paper
Multiparty Asynchronous Session Types — Honda, Yoshida & Carbone POPL 2008, multiparty generalisation
Introduction to Choreographies — Montesi 2023 (Cambridge), the canonical textbook
On the Monitorability of Session Types — Bartolo Burlò, Francalanza & Scalas ECOOP 2021, runtime monitoring
Session Types
Pact - A Choreographic Language for Agentic Ecosystems
Commitment-Based Protocol
Commitment Machines
Flexible Protocol Specification and Execution
Algebraic Effects

Pact - A Choreographic Language for Agentic Ecosystems

Pact: A Choreographic Language for Agentic Ecosystems

Reference: Gopinathan, K., Feser, J., Naim, M., Tavares, Z. & Bingham, E. (2026). 2nd International Workshop on Choreographic Programming (CP 2026), Boulder, CO, June 15–19. arXiv:2605.03143v1 [cs.PL], 4 May 2026 (talk paper). Basis Research Institute. URL

Summary

Gopinathan et al. extend Choreographic Programming to the open-systems setting where participants are self-interested and may not faithfully execute a protocol. Choreographies (Montesi 2023; Bates et al. 2025) give correct-by-construction, deadlock-free distributed protocols by writing one global program that is mechanically projected to local endpoints, but they assume cooperative participants — they cannot answer why an autonomous agent should follow the projected protocol. Pact answers that question by adding three operators to a core choreographic calculus: agent.choose(τ) for explicit strategic non-determinism, agent.values(x) for declared utility dependencies, and world.choose(τ) for exogenous “nature” variables that capture each agent’s priors over the environment. Every Pact program then maps unambiguously to a formal extensive-form game.

The headline analysis is a decision-policy solver built on the Memo Programming Language (Chandra et al. 2025), a probabilistic-programming DSL for cognitive theory-of-mind models. From the projected Pact program a memo model is constructed in which each role recursively simulates the other to depth ℓ; running inference yields a level-ℓ bounded-rational policy mapping observations to choices. Applied to the canonical book-seller choreography the solver recreates Akerlof’s Market for Lemons: at depth 0 the buyer naïvely treats price as a signal of quality and the seller exploits this; as ℓ grows the acceptance probability flattens. The implementation is an embedded Python DSL on top of the Effectful algebraic-effects library, with endpoint projection realised as effect handlers. The paper is positioned as preliminary work; next steps named are formalising the semantics, proving correctness of projection-to-game, and adding incentive-compatibility / equilibrium / mechanism-design analyses.

Key Ideas

Choreography + game theory: a global protocol gets three game-theoretic operators (choice, value, nature) so that endpoint projection produces both a runnable program and a formal game.
values as type signature, not utility: declarations name the variables that influence an agent’s payoff but not the function — utilities are private and adversarially incentive-incompatible to disclose. The role of values is to constrain which protocols are mutually negotiable.
Theory-of-mind solver via memo: bounded-rational level-ℓ recursion over agent models, with the recursion bottoming out at naïve priors at ℓ = 0.
Lemons re-derived from a choreography: information asymmetry over an exogenous book.quality variable is enough to reproduce Akerlof’s unravelling result on the bookseller protocol.
Algebraic-effects implementation: endpoint projection implemented as effect handlers in Python (effectful); choreography is a single program that runs differently depending on which handler (Endpoint Projection) is installed.
Motivation framed against LLM agent failure modes: prompt injection, sycophancy, and coercion of LLM agents are cited as the reasons untrusted-counterpart coordination needs formal protocol artefacts rather than free-form natural-language negotiation.

Connections

Conceptual Contribution

Claim: Choreographic protocols for autonomous-agent ecosystems should make agent strategy first-class — explicit choices, declared utility dependencies, and exogenous priors — so that every protocol corresponds to a formal game and can be analysed for whether self-interested agents will participate.
Mechanism: Three new constructs added to a core choreographic calculus (agent.choose, agent.values, world.choose); a structural map from Pact programs to extensive-form games; a level-ℓ bounded-rational decision-policy solver built by translating the projected program into a Memo Programming Language theory-of-mind model and running probabilistic inference over it; an embedded-DSL implementation in Python via algebraic effects realising endpoint projection.
Concepts introduced/used: Choreographic Programming, Endpoint Projection, Theory of Mind, Memo Programming Language, Bounded Rationality, Market for Lemons, Mechanism Design, Algebraic Effects, Negotiation, Game-Theoretic Trust, Mentalistic Semantics
Stance: position / preliminary engineering (CP 2026 workshop talk paper)
Relates to: A contemporary LLM-era restatement of the individual-rationality answer to “why follow a protocol?” first formalised by Deals Among Rational Agents (Rosenschein & Genesereth 1985) and lifted to mental attitudes by Intention Is Choice with Commitment (Cohen & Levesque 1990). The paper is structurally adjacent to — but does not engage — the entire commitment-protocol tradition: Flexible Protocol Specification and Execution (Yolum & Singh 2002) gives a global protocol semantics in the Event Calculus with explicit Create / Discharge / Cancel / Release / Assign / Delegate operations whose runs project to local agents in a way directly analogous to choreographic endpoint projection, and A Commitment-Based Approach to Agent Communication (Fornara & Colombetti 2004) gives an operational FSM semantics for the same primitives. ACL Rethinking Principles (Singh 1998) and Verifiable Semantics for ACLs (Wooldridge 1998) anticipate the central limitation: a semantics grounded in agent utilities and recursive belief models is unverifiable from message traces alone — the very failure modes the paper opens with (prompt injection, sycophancy, coercion) destabilise the priors and rationality assumptions the solver depends on. The Lemons demo, taken at face value, is an argument for institutional / commitment mechanisms (warranties, refund obligations, certification) of the kind Singh’s programme articulates rather than for theory-of-mind solving. The constructive synthesis the paper does not propose is to layer commitment operations onto the choreographic substrate so that protocols carry both a public, observable commitment trace (Singh-style verifiability) and a game-theoretic acceptability analysis (Pact-style strategic reasoning); choreographies are a particularly natural host because endpoint projection already gives the global-to-local move that Commitment Machines approximates by FSM compilation. On the LLM-agent side the paper’s diagnosis converges with Why AI Agents Communicate In Human Language (formal protocol artefacts beat free-form natural-language negotiation) and complements the standardisation argument of LLM Agent Communication Protocol Requires Urgent Standardization.

Tags

Introduction to Choreographies

Reference: Montesi, F. (2023). Introduction to Choreographies. Cambridge University Press, Cambridge, UK. ISBN 978-1-108-47744-7 (hardback). URL. Citation-only entry; the book is paywalled and the local vault does not hold a source PDF.

Summary

Montesi’s Introduction to Choreographies is the first textbook-level treatment of Choreographic Programming. It develops the field systematically from process-calculus foundations (CCS, π-calculus) through binary and multiparty Session Types to fully-fledged choreographic calculi and their compilation to distributed implementations via Endpoint Projection. The book is organised around the correspondence theorem — the result that a well-formed choreography is bisimilar to the parallel composition of its endpoint projections — and chapters incrementally build the language features (asynchrony, recursion, higher-order communication, knowledge of choice, dynamic participants) needed to express real protocols while preserving deadlock-freedom and communication safety by construction. Worked examples include classic protocols (bookseller, two-buyer, third-party authentication) implemented as choreographies and then projected to executable code.

The book is the canonical contemporary reference and the natural starting point for any reader entering the choreographic-programming literature; it is the primary background that Pact (Gopinathan et al. CP 2026) cites for choreographic programming as such, and the bridge from the foundational papers (Structured Communication-Centred Programming for Web Services, Multiparty Asynchronous Session Types) to the modern implementation landscape (Choral, HasChor, ChoRus). Held in the vault primarily as an authoritative pointer rather than a paper-summary entry.

Connections

Conceptual Contribution

Claim: Choreographic programming has matured to the point where a single textbook can present the field as a coherent discipline — process calculi, session types, choreographic calculi, projection, and implementation — with the correspondence theorem (well-formed choreography ≡ parallel composition of its projections) as the organising spine.
Concepts introduced/used: Choreographic Programming, Endpoint Projection, Session Types, correspondence theorem, knowledge of choice, asynchrony
Stance: textbook / canonical reference
Relates to: The pedagogical synthesis of Structured Communication-Centred Programming for Web Services (Carbone-Honda-Yoshida 2007/2012) and Multiparty Asynchronous Session Types (Honda-Yoshida-Carbone POPL 2008) plus the subsequent decade of work; the natural entry point for understanding Pact - A Choreographic Language for Agentic Ecosystems in lineage. Companion to other foundational textbook references in the vault such as Foundations of Logic Programming - Lloyd.

Tags

#choreographic-programming #textbook #session-types #foundational #citation-only

Multiparty Asynchronous Session Types

Reference: Honda, K., Yoshida, N. & Carbone, M. (2008). Proceedings of the 35th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’08), San Francisco, CA, pp. 273–284. ACM. DOI: 10.1145/1328438.1328472. Journal version: Journal of the ACM 63(1):9, 2016, DOI: 10.1145/2827695. Source file: honda-yoshida-carbone-popl08.pdf. URL

Summary

Honda, Yoshida and Carbone generalise the binary session-type discipline of Honda (1993) and Honda-Vasconcelos-Kubo (1998) to multiparty asynchronous communication: a single global type describes the interaction protocol among N ≥ 2 participants, and per-participant local types are derived by a syntactic projection function that translates each global statement into the participant’s local view of it. A process calculus extending the asynchronous π-calculus is typed against these local types; the central technical result is the subject reduction and progress theorem: a system of well-typed processes is deadlock-free, communication-safe (no message-type mismatch), and session-fidelity-preserving (the runtime trace conforms to the global type, projected). This three-tier structure — global types, local types via projection, processes typed against local types — is the formal foundation that the entire contemporary multiparty session-types and choreographic-programming literature inherits.

The paper’s intellectual contribution is to make the global protocol a typed object whose well-formedness can be checked once, with the well-typedness of every projected role following automatically. Where binary session types describe the obligations of two endpoints separately and rely on duality, multiparty session types describe the joint protocol once and project to as many roles as needed, with a coherence condition (each branching point is observed by every relevant participant) ensuring projections are mutually consistent. The treatment is asynchronous: send is non-blocking, messages are buffered in per-channel queues, and the type system tracks the resulting message-order obligations. The framework is the direct precursor of contemporary choreographic-programming languages (Choral, HasChor, ChoRus, Pact) and of the runtime-monitoring theory developed in On the Monitorability of Session Types.

Key Ideas

Global type: a single typing artefact G describing the interaction among N participants — primitives include p → q : ⟨S⟩.G (participant p sends a value of type S to q, then G), branching p → q : {ℓᵢ : Gᵢ}, recursion μt.G, and parallel composition.
Local type / projection: G ↾ p is the projection of G to participant p, syntactically translating each global statement into the corresponding send/receive/select/branch from p’s perspective.
Coherence (well-formedness): a global type is well-formed iff every choice point is observed by every relevant participant — the multiparty analogue of the connectedness condition in Structured Communication-Centred Programming for Web Services.
Asynchronous π-calculus substrate: processes communicate over typed session channels with non-blocking send and FIFO queues; each session is opened with a fresh name and closed structurally.
Subject reduction: well-typedness is preserved under reduction.
Communication safety: no well-typed system ever sends a value whose type the receiver does not expect.
Session fidelity / progress: the runtime trace of a well-typed system is a refinement of the projected local types, and well-typed systems whose buffers are empty cannot deadlock.
Type-driven engineering payoff: type-check the global protocol once, get communication-safety guarantees for every role for free.

Connections

Conceptual Contribution

Claim: Multiparty distributed communication is best disciplined by a single global type describing the joint protocol of all participants, from which per-participant local types are derived by mechanical projection; well-typedness of the global type plus a coherence condition ensuring choice points are observed by all relevant parties is sufficient to guarantee that every projected process is communication-safe, deadlock-free, and faithful to the global protocol.
Mechanism: Define global types as a calculus over N ≥ 2 participants with sending, branching, recursion, parallel composition; define local types as session types with send/receive/select/branch; define a syntactic projection G ↾ p from global to local types per participant; type processes (extended asynchronous π-calculus with FIFO message buffers) against the projected local types; prove subject reduction (well-typedness preserved under reduction), communication safety (no type-mismatched messages), and progress (well-typed systems with empty buffers do not deadlock).
Concepts introduced/used: Session Types, multiparty session types, global type, local type, projection, coherence, subject reduction, asynchronous π-calculus, communication safety, session fidelity
Stance: foundational / formal-semantic
Relates to: Companion to Structured Communication-Centred Programming for Web Services (Carbone-Honda-Yoshida ESOP 2007 / TOPLAS 2012) — the two papers together establish the modern global types → local types → processes pipeline that all subsequent choreographic-programming and multiparty session-types work inherits. Without the multiparty extension here, the binary session-type substrate of Carbone-Honda-Yoshida 2007 cannot scale to the N-participant choreographies that real protocols need. Underwrites the contemporary textbook Introduction to Choreographies (Montesi 2023). Provides the type-system substrate that On the Monitorability of Session Types (Bartolo Burlò et al. ECOOP 2021) lifts into a runtime-monitoring theory, and that Pact - A Choreographic Language for Agentic Ecosystems adds game-theoretic operators on top of. The structural counterpart in the agent-communication tradition is Commitment Machines - Yolum and Singh / Flexible Protocol Specification and Execution: both lineages (multiparty session types ↔ Yolum-Singh commitment protocols) take a globally-specified N-participant protocol, project to per-role views, and prove the projection preserves a key correctness property (communication safety here, commitment discharge there). The π-calculus substrate descends from Communicating Sequential Processes (Hoare 1978) and Milner’s π-calculus.

Tags

Structured Communication-Centred Programming for Web Services

Reference: Carbone, M., Honda, K. & Yoshida, N. (2007/2012). Conference: European Symposium on Programming (ESOP 2007), LNCS 4421: 2–17. Journal: ACM Transactions on Programming Languages and Systems 34(2): 8:1–8:78, June 2012. DOI: 10.1145/2220365.2220367. Source file: carbone-honda-yoshida-toplas12.pdf. URL

Summary

Carbone, Honda and Yoshida introduce the formal foundation of what is now called Choreographic Programming: a programming paradigm in which one writes a global description of how a set of communicating agents interact — who sends what to whom, in what order, under which choices — and a mechanical endpoint projection derives the local program for each participant. The paper presents two formal calculi side by side: a global calculus whose terms describe interaction patterns from an Olympian, single-program perspective (e.g. A → B : op⟨v⟩.G, “A sends op carrying v to B, then continue with G”), and an end-point calculus — a session-typed asynchronous π-calculus — that describes the same interactions from each participant’s local perspective. The bridge between them is a projection function that, given a well-formed global description, produces a tuple of end-point processes, one per participant. The central technical result is a soundness and completeness correspondence (the Theorem of End-Point Projection): the global calculus and the projected end-point system are bisimilar, and the projection produces deadlock-free, communication-safe processes whenever the source global description satisfies a small set of well-formedness conditions (notably connectedness — every participant of a continuation must have been informed of the choice — and thread linearity).

The paper’s intellectual move is to elevate the interaction itself to the status of programmable artefact, replacing the dominant view in which communication patterns are inferred post hoc from local code. The motivation is the W3C Web Services Choreography Description Language (WS-CDL), but the calculus is independent of that context and has since become the foundation of an entire research line: subsequent work generalises the binary session-type substrate to multiparty (Multiparty Asynchronous Session Types, Honda-Yoshida-Carbone POPL 2008), embeds choreographies in production languages (Choral, HasChor, ChoRus), and extends the framework toward adversarial settings via cryptographic primitives. Every contemporary choreographic-programming paper — including Pact — descends from this work.

Key Ideas

Global calculus: a process calculus whose terms describe interactions from a vantage point above all participants. Primitives include sending (A → B : op⟨v⟩.G), branching (A → B : {labelᵢ : Gᵢ}), parallel composition, recursion, and assignment.
End-point calculus: an asynchronous, session-typed π-calculus describing each participant’s local view; communication occurs over named sessions with structured types.
Endpoint projection (EPP): a syntactic transformation ⟦G⟧_A mapping a global description G and a participant A to an end-point process. Type-driven and compositional.
Theorem of End-Point Projection: for every well-formed global description G, the parallel composition of its end-point projections is operationally equivalent (bisimilar) to G itself, and is deadlock-free and communication-safe.
Connectedness condition: a syntactic well-formedness check ensuring every participant in a continuation has been informed of the branch taken — this is what rules out projections in which one participant chooses a branch the others cannot observe.
Thread linearity: each session channel is owned by exactly one thread, making projection unambiguous.
Session types as the substrate: the global calculus is typed by global types, projected to local types per participant; well-typedness of the source guarantees well-typedness of all projections.
Operational correspondence at the core: global reductions are matched step-for-step by end-point system reductions, and vice versa, modulo τ-transitions for internal sequencing.

Connections

Conceptual Contribution

Claim: Distributed communication should be programmed globally — as a single artefact describing the joint interaction of all participants — rather than locally as per-process send/receive code, because the global view exposes the protocol’s structure to type-checking and admits a sound-and-complete mechanical projection to per-role implementations that are deadlock-free and communication-safe by construction.
Mechanism: Two parallel calculi (a global calculus describing interactions and an end-point asynchronous π-calculus describing local processes); a session-type discipline at both levels with a projection theorem showing global types project to local types role-by-role; a syntactic endpoint projection function ⟦G⟧_A mapping global descriptions to local processes; well-formedness conditions (connectedness, thread linearity) sufficient to guarantee that projection preserves operational behaviour and yields communication safety; the central Theorem of End-Point Projection establishing bisimulation between the global system and its projected end-point composition.
Concepts introduced/used: Choreographic Programming, Endpoint Projection, Session Types, global type, local type, π-calculus, well-formedness (connectedness, thread linearity)
Stance: foundational / formal-semantic
Relates to: The taproot of the choreographic-programming literature. Sister paper to Multiparty Asynchronous Session Types (Honda-Yoshida-Carbone POPL 2008), which generalises the binary session-type substrate here to N-party interactions; together the two papers establish the modern global-types / local-types / endpoint-projection triangle. Underwrites the contemporary canonical reference Introduction to Choreographies (Montesi 2023). The runtime-monitoring story for the projected end-points is given by On the Monitorability of Session Types (Bartolo Burlò et al. ECOOP 2021). Structurally the exact analogue of Commitment Machines - Yolum and Singh (Yolum-Singh ATAL-01) and Flexible Protocol Specification and Execution (Yolum-Singh AAMAS-02) in the agent-communication tradition: both pairs (Carbone-Honda-Yoshida ↔ Yolum-Singh) take a globally-specified protocol, define a mechanical projection to per-role behaviour, and prove the projection preserves the relevant correctness property — communication safety on the choreography side, commitment discharge on the commitment-protocol side. Direct ancestor of Pact - A Choreographic Language for Agentic Ecosystems (Gopinathan et al. CP 2026), which adds game-theoretic operators on top of this substrate. The π-calculus dependency goes back to Communicating Sequential Processes (Hoare 1978) for the synchronous-communication root.

Tags

Levels Of Social Orchestration

Levels of Social Orchestration for Agentic Systems

Reference: Chopra, Bhattacharya, Leibo, Raskar (2025). ICML 2025 (MIT, Google DeepMind). Source file: agentic_draft.pdf. URL

Summary

The authors argue that as AI agents scale to billions, beneficial collective behaviour depends less on maximizing individual intelligence and more on discovering interaction protocols. They introduce Large Population Models (LPMs) - differentiable, end-to-end trainable protocols spanning simulated and physical agent networks - as a paradigm shift from LLMs (data -> language) to LPMs (protocol -> population).

They propose a five-level taxonomy of agentic systems: L1 Perceive, L2 Automate, L3 Connect (all within human cognitive bounds), then L4 Navigate and L5 Transform (beyond Dunbar-scale human coordination). Case studies span pandemic response, traffic coordination, and Coachella-style crowd management, framing the progression from information intelligence to collective orchestration.

Key Ideas

Protocol-centric intelligence: rules of interaction beat bigger individual models.
Large Population Models (LPMs): differentiable protocols over synthetic+physical agents.
L1-L5 levels: Perceive, Automate, Connect, Navigate, Transform.
Human Connectivity Barrier (~1500 people) as natural scaling limit.
Case studies in pandemics, traffic, crowd scheduling.

Connections

Conceptual Contribution

Claim: At population scale, beneficial AI comes from protocol design, not model scaling; the paradigm must shift from LLMs (data to language) to Large Population Models (protocol to population).
Mechanism: Introduces differentiable, end-to-end trainable LPMs spanning simulated and physical agents; proposes a 5-level taxonomy (Perceive/Automate/Connect within human cognitive bounds, Navigate/Transform beyond them); case studies in pandemic response, traffic, crowd management.
Concepts introduced/used: Large Population Models, Differentiable Protocols, Human Connectivity Barrier, Multi-Agent Systems, LLM Agents, Self-Adaptive Systems, Emergent Communication
Stance: foundational / engineering
Relates to: Provides the level-taxonomy lens under which Ripple Effect Protocol sits as an L4 mechanism; echoes the “protocols-not-messages” critique of Why AI Agents Communicate In Human Language; its macro vision contrasts with the infrastructural surveys Survey Of AI Agent Protocols and Survey Of Agent Interoperability Protocols.

Tags

An Interaction-oriented Agent Framework for Open Environments

An Interaction-oriented Agent Framework for Open Environments (Mercurio)

Reference: Baldoni, Baroglio, Bergenti, Marengo, Mascardi, Patti, Ricci, Santi (2011). AIIA 2011 (Italian AI Association)*. Source file: cbcl-ref/AI_IA2011.pdf. URL

Summary

The authors propose Mercurio, an agent-programming framework for open multi-agent systems that unifies direct (speech-act) and indirect (environment-mediated) communication under a single social/observational semantics based on commitments. Mercurio has three levels — specification (constitutive and regulative rules over a domain model), programming abstractions (Agents and Artifacts in the A&A meta-model), and infrastructure (built on JaCaMo integrating Jason, CArtAgO, and MOISE).

Commitment-based protocols give a public, verifiable meaning to actions (replacing mentalistic ACL semantics); constitutive rules define what counts as what, while regulative rules impose temporal constraints on the social state. Artifacts reify interaction patterns and the social state itself, enabling the environment to monitor and detect violations. The framework thus conjugates MAS flexibility with software-engineering modularity and compositionality, targeting e-government, cross-business, and service-oriented applications.

Key Ideas

Commitment-based social semantics replaces mentalistic ACL semantics.
Three levels: specification, programming abstractions, infrastructure.
Separation of constitutive and regulative rules.
Artifacts (A&A / CArtAgO) as first-class environment entities.
JaCaMo stack (Jason + CArtAgO + MOISE) as reference infrastructure.

Connections

Conceptual Contribution

Claim: Open multi-agent systems need a single, publicly verifiable interaction semantics that unifies direct (speech-act) and indirect (environment-mediated) communication; commitments plus Agents-and-Artifacts supply it and can be layered onto an existing AOP stack.
Mechanism: Mercurio stratifies into three levels. (1) Specification: a domain model plus constitutive rules (“what counts as what”) and regulative rules (temporal constraints on the social state). (2) Programming abstractions: the A&A meta-model (agents + artifacts) where artifacts reify interaction patterns and the social state itself. (3) Infrastructure: the JaCaMo stack (Jason + CArtAgO + MOISE) runs the above so violations are environment-detectable and the social state is inspectable.
Concepts introduced/used: Mercurio Framework, Commitment-Based Protocol, Constitutive Rules, Regulative Rules, Agents and Artifacts, JaCaMo, Jason, CArtAgO, MOISE, Social State
Stance: engineering
Relates to: Concretely instantiates the social-semantic programme of Agent Communication Languages - Rethinking the Principles and the open-issue agenda of Trends in Agent Communication Language and The State of the Art in Agent Communication Languages; its environment-reified interaction complements the self-organisation of A Composite Self-organisation Mechanism in an Agent Network.

Tags

Ensuring Trustworthy and Ethical Behaviour in Intelligent Logical Agents

Reference: Stefania Costantini (2020; arXiv 2024). arXiv:2402.07547v1. Source file: 2402.07547v1.pdf. URL

Summary

Proposes runtime self-checking techniques for computational-logic-based (BDI-style) agents so they can monitor their own behaviour for trustworthiness and ethical compliance, beyond what static a-priori verification can guarantee. The core contribution is A-ILTL (Agent-Oriented Interval Linear Temporal Logic), a specification language for metaconstraints and evolutionary expressions that an agent can apply introspectively to its own state, goals, and actions.

Costantini argues that learning, open MAS, and long-lived autonomous systems make static model checking insufficient; agents must reflect on their behaviour and take counter-measures. The paper relates the approach to self-aware computing, Arkin’s ethical governor, Metacognitive Loops, and “restraining bolts” from reinforcement learning.

Key Ideas

Runtime verification (RV) complements static model checking for agents
A-ILTL: interval-LTL with metarules for self-checking BDI agents
Reification/naming mechanism allows meta-predicates solve/solve_not to gate actions
Trace expressions and introspection for ethical reasoning
Agents should reflect and self-improve — not merely obey hardcoded rules

Connections

Conceptual Contribution

Claim: A-priori (static) verification is insufficient for learning, evolving, or open-MAS agents; agents must themselves continuously self-monitor against ethical and behavioural constraints at runtime via a lightweight logic-based introspection mechanism.
Mechanism: Introduces A-ILTL (Agent-Oriented Interval Linear Temporal Logic) — a language-independent interval-temporal logic for specifying meta-constraints over an agent’s BDI state; Evolutionary A-ILTL Expressions include past events, a temporal property, future expected events, and repair countermeasures. Meta-rules with solve/solve_not meta-predicates gate object-level actions. Positioned as a complementary runtime “restraining bolt” alongside a-priori verification and RL-based ethical governors.
Concepts introduced/used: Runtime Verification, A-ILTL, BDI Agents, BDI, Mental State, Machine Ethics, Self-aware Computing, Self-Adaptive Systems, Meta-rules, Trace Expressions, Ethical Governor, Metacognitive Loop, Restraining Bolts
Stance: formal / ethics-engineering
Relates to: Builds on the logical-agent substrate of Foundations of Logic Programming - Lloyd and the BDI tradition surveyed in Intelligent Agents Theory and Practice. Its runtime-monitoring stance complements the empirical failure-mode work of Why Do Multi-Agent LLM Systems Fail and the trustworthiness framing of AI Agents Under Threat. Shares the “agent knows its own norms” spirit with commitment-based semantics in Agent Communication And Institutional Reality.

Tags

Are Multiagent Systems Resilient to Communication Failures

Are Multiagent Systems Resilient to Communication Failures?

Reference: Philip N. Brown, Holly P. Borowski, and Jason R. Marden (2017). arXiv:1710.08500 (American Control Conference 2018). Source file: 1710.08500v1.pdf. URL

Summary

Studies whether game-theoretic multiagent systems that tolerate “offline” design-time information loss also tolerate “online” runtime communication failures. Using potential games as the canonical setting, the authors show a surprising negative result: even a single communication failure about a weakly-coupled (“inconsequential”) agent’s action can drive best-response and log-linear-learning dynamics to arbitrarily poor equilibria, regardless of which proxy-payoff evaluator the ignorant agent uses.

The paper also identifies positive results — identical-interest games with the max evaluator remain well-behaved under a single failure — and proposes a “coarse potential alignment” certificate for when proxy payoffs are safe. It further shows a paradox: in identical-interest games, performance can improve when more agents are denied information about an inconsequential player.

Key Ideas

Proxy-payoff evaluators (sum/max/min/mean) and their admissibility
Single communication failure can destabilise potential-game equilibria
Identical-interest + max evaluator is the only generally safe combination
“Inconsequentiality” as an epsilon-weak-coupling definition
Larger action spaces (more profiles) make games more susceptible

Connections

Conceptual Contribution

Claim: Even when a single “weakly-coupled” agent loses information about another’s action, standard game-theoretic multi-agent control (potential games, identical-interest games, log-linear learning) can collapse to arbitrarily bad equilibria — resilience to communication failures is fundamentally limited by the structure of the problem, not just the learning rule.
Mechanism: Formalise the notion of ε-inconsequentiality (a player whose action change barely affects another’s payoff) and proxy payoff evaluators (max/mean/min/sum over unobserved actions); prove negative theorems showing acceptable evaluators can induce pathological Nash equilibria, then positive structural results (ε-inconsequential + max-evaluator + identical-interest ⇒ resilience) and “informational paradox” results where removing communication can improve outcomes.
Concepts introduced/used: Potential Games, Log-linear Learning, Proxy Payoff Evaluators, Inconsequentiality, Communication Failures, Distributed Optimization, Nash Equilibrium Pathologies, Nash Equilibrium, Best-Response Dynamics, Price of Anarchy, Identical-Interest Games
Stance: formal / game-theoretic
Relates to: Provides the theoretical foundation for robustness concerns raised empirically in Why Do Multi-Agent LLM Systems Fail and A Composite Self-organisation Mechanism in an Agent Network. The inconsequentiality notion parallels weak-coupling arguments in Gossip Protocols and Gossip-based Aggregation in Large Dynamic Networks.

Tags

Multi-Agent Collaboration in AI - Wasif Tunkel

Multi-Agent Collaboration in AI: Enhancing Software Development with Autonomous LLMs

Reference: Mubeen Wasif and David Tunkel (2025). ResearchGate preprint. Source file: 16.pdf

Summary

A short survey-style paper arguing that multi-agent LLM systems can improve software-development workflows by distributing tasks (requirements, code generation, testing, documentation) across specialised autonomous agents that communicate via structured dialogue. The authors report qualitative experimental findings that division of labour and iterative refinement among agents produce higher-quality outputs than single-agent baselines.

The paper also surveys open challenges: coordination overhead, response consistency, bias propagation, and governance/security concerns. It advocates human-in-the-loop validation and explainability (XAI) as mitigations, and points to future integration with IDEs, CI/CD, and RAG.

Key Ideas

Specialised agent roles (coder, tester, documenter) mirror human dev teams
Structured inter-agent dialogue enables iterative code refinement
Hybrid human-AI teams recommended for reliability
Coordination cost, bias propagation, accountability are unsolved
RAG and adaptive prompting as future contextual-awareness tools

Connections

Conceptual Contribution

Claim: Multi-agent LLM systems, with role-specialised agents (coder, tester, documenter) communicating through structured dialogue, outperform single-agent LLMs on software-engineering tasks by mirroring human team division-of-labour.
Mechanism: Survey-plus-experiment discussion: assign distinct agents to requirement analysis, code generation, debugging, documentation; use iterative feedback loops and structured prompts; report efficiency/accuracy gains while flagging coordination overhead, bias propagation, and security concerns; advocate human-in-the-loop governance.
Concepts introduced/used: LLM Agents, Role-specialised Agents, Human-in-the-loop, Agent Coordination Overhead, Explainable AI, Multi-Agent Systems, Retrieval-Augmented Generation, Division of Labour
Stance: engineering / survey
Relates to: A light-weight practitioner view of the same problem space that Why Do Multi-Agent LLM Systems Fail tackles rigorously, and that Agents Framework - Zhou et al operationalises as an open-source library. Shares the communication-protocol concern with A Scalable Communication Protocol for Networks of LLMs.

Tags

The BOID Architecture

The BOID Architecture: Conflicts Between Beliefs, Obligations, Intentions and Desires

Reference: Broersen, Dastani, Hulstijn, Huang, van der Torre (2001). Proceedings of the Fifth International Conference on Autonomous Agents (AGENTS’01), Montreal. Source file: broersen_01_boid.pdf. URL

Summary

This paper introduces the BOID architecture, a deontic extension of the classic BDI (Belief-Desire-Intention) agent model that adds Obligations as a first-class motivational attitude alongside Beliefs, Desires, and Intentions. The authors argue that autonomous agents must reason not only about what they believe, want, and plan, but also about the norms and social commitments that constrain them, and that modeling obligations explicitly lets the architecture handle conflicts between self-interested goals and externally imposed duties.

The central contribution is a classification of conflict types between the four components (e.g., BO, BD, BI, OD, OI, DI, and triple/quadruple conflicts such as BOD and BOID) and a corresponding taxonomy of agent types determined by orderings over which component overrules which. Six “realistic” orderings yield named agent types: realistic, simple-minded/stable (BIDO, BIOD), selfish (BDIO, BDOI), social (BOID, BOID), and open-minded. Conflicts are resolved by feedback loops in the control cycle that iteratively apply rules from each component, producing one or multiple extensions in the sense of Reiter’s default logic. An additional planning component selects actions from intentions.

Key Ideas

Deontic extension of BDI: Obligations become a fourth motivational attitude.
Four components as input/output black boxes producing sets of formulas (extensions).
Taxonomy of conflicts: binary (BO, BD, BI, OD, OI, DI), triple (BOD, BOI, BDI, OID), quadruple (BOID).
Agent types as orderings over components: realistic, simple-minded, selfish, social, open-minded.
Conflict resolution via feedback-loop control architecture (extensions constructed before selection).
Connection to Reiter’s default logic and Thomason’s BDP logic.
Single-extension vs multiple-extension BOID; planning component selects one final extension.

Connections

Conceptual Contribution

Claim: Autonomous agents require obligations as a first-class motivational attitude alongside BDI, and an agent’s character can be formally identified with the priority ordering used to resolve conflicts between beliefs, obligations, intentions, and desires.
Mechanism: Four component black boxes (B, O, I, D) produce extensions over a propositional language; an ordering function rho on rules determines which components override others; a feedback-loop control cycle iteratively applies applicable rules; a planning component selects a single extension. The 24 possible orderings collapse to six realistic agent types.
Concepts introduced/used: BDI, Deontic Logic, Default Logic, Agent Types, Norms and Obligations, Agent Architecture, Multi-Agent Systems
Stance: formal
Relates to: Extends the BDI foundations referenced throughout the vault (Agent-Oriented Programming, BDI) with normative reasoning relevant to Agent Communication And Institutional Reality; provides a conflict-resolution substrate that agent communication languages (FIPA-ACL, KQML) implicitly assume when performatives carry commissive or directive force.

Tags

Agent-Oriented Programming

Reference: Shoham, Y. (1993). Artificial Intelligence 60, Elsevier. Source file: shoam-aop.pdf. URL

Summary

Shoham introduces Agent-Oriented Programming (AOP) as a specialization of object-oriented programming in which the state of each module — now called an agent — is a mental state composed of beliefs, capabilities, decisions/choices, commitments, and obligations. Interpretation of these components is formally grounded in an extension of standard epistemic logics that adds temporality, obligation, decision, and capability operators.

Agents communicate via speech-act-inspired primitives (inform, request, offer, promise, decline, etc.), constrained by rules such as honesty and consistency. The paper defines a class of agent interpreters and presents AGENT-0, a concrete implemented language whose semantics is tied to the mental-state logic. Shoham also discusses “agentification” — converting arbitrary devices into AOP-programmable agents — and situates AOP against BDI architectures, speech act theory, and McCarthy’s Elephant2000.

Key Ideas

AOP as OOP specialization with mental-state components.
Agents constrained by honesty/consistency on communicative acts.
Speech-act-typed primitives as message types.
AGENT-0 language and interpreter.
“Agentification” of arbitrary devices.

Connections

Conceptual Contribution

Claim: Programming can be fruitfully specialised to an “agent” paradigm in which module state is a formally specified mental state and inter-module communication is a speech act constrained by rational/ethical rules.
Mechanism: Shoham extends standard modal-epistemic logic with temporal, obligation, decision and capability operators, defines the mental-state components of an agent (belief, capability, commitment, choice, obligation), then specifies a generic agent interpreter cycle (update mental state, execute commitments, handle incoming messages) and instantiates it in AGENT-0, whose programs are condition-action rules over mental state and whose messages are typed INFORM/REQUEST/UNREQUEST primitives.
Concepts introduced/used: Agent-Oriented Programming, Mental State, Commitment, AGENT-0, Speech Act Theory, Agentification, BDI, Honesty Constraint
Stance: foundational
Relates to: Establishes the mentalistic ACL stance later criticised by Agent Communication Languages - Rethinking the Principles and surveyed by Intelligent Agents Theory and Practice; AGENT-0’s speech-act primitives anticipate KQML as an Agent Communication Language and FIPA-ACL; the mental-state architecture is reused in An Interaction-oriented Agent Framework for Open Environments.

Tags

Multiagent Systems Sycara

Multiagent Systems

Reference: Katia P. Sycara (1998). AI Magazine, Summer 1998, Vol. 19, No. 2, pp. 79-92. Source file: Multiagent_Systems.pdf. URL

Summary

Sycara’s survey introduces multi-agent systems (MAS) as a paradigm for tackling problems too large, complex, or distributed for a single agent, presenting the key characteristics that distinguish MAS: each agent has incomplete information, there is no global control, data is decentralized, and computation is asynchronous. She motivates MAS via open systems like the Internet where heterogeneous agents from different designers must interoperate, and surveys the main research problems: coordination, communication, negotiation, coherence, conflict resolution, and reasoning about other agents.

She organizes the field around issues (enabling communication, individual agent reasoning, adaptive coordination, protocols like Contract Net and KQML, reactive vs. deliberative architectures, emergent behavior) and applications (information gathering, e-commerce, manufacturing, health care, distributed planning). Throughout she emphasizes coherence — how locally-acting agents can achieve globally reasonable performance — as the defining challenge.

Key Ideas

Four MAS characteristics: incomplete info, no global control, decentralized data, async computation.
Coherence as the central research challenge.
Spectrum from reactive (stimulus-response) to deliberative (BDI) architectures.
Coordination requires reasoning about other agents’ expected behavior.
Organizations, markets, and scientific-community metaphors for MAS structure.

Connections

Conceptual Contribution

Claim: Multi-agent systems are the appropriate paradigm for open, distributed, heterogeneous problem-solving; they are characterised by four structural properties (incomplete info, no global control, decentralised data, async computation) and unified by the problem of achieving coherence through local decisions.
Mechanism: Survey-style synthesis organising the MAS field around: motivations (modularity, legacy interop, distributed data), core challenges (coherent coordination, negotiation, planning, conflict resolution), architectures (reactive, deliberative/BDI, hybrid), organisational metaphors (hierarchy, market, community, scientific), protocols (Contract Net, KQML), and application domains (info gathering, e-commerce, manufacturing, aircraft maintenance).
Concepts introduced/used: Multi-Agent Systems, Coherence, Problem-Solving Coherence, Contract Net Protocol, BDI Architecture, Reactive vs Deliberative Agents, Negotiation, Joint Intentions, Organizational Metaphors
Stance: survey / foundational
Relates to: Canonical MAS reference informing nearly every other note; defines the field that ACL Rethinking Principles and Verifiable Semantics for ACLs critique; organisational metaphors dovetail with How Do Committees Invent; negotiation/coordination theme continued in Toward Automated Evolution of ACLs and Coordinating Agents Using ACL Conversations.

Tags

Intelligent Agents Theory and Practice

Intelligent Agents: Theory and Practice

Reference: Wooldridge, M., Jennings, N. R. (1995). Knowledge Engineering Review. Source file: woodridge_intelligent_agents.pdf. URL

Summary

A foundational survey that organizes the agent-based computing field into three tightly coupled concerns: agent theories (formal specifications of what an agent is, often via intentional notions such as belief, desire, intention, obligation), agent architectures (software/hardware designs satisfying those specifications, e.g., BDI, subsumption, layered), and agent languages (programming languages whose primitives embody the theorists’ concepts).

Wooldridge and Jennings distinguish a weak notion of agency (autonomy, social ability, reactivity, pro-activeness) from a stronger AI-centric notion involving mentalistic attributes (knowledge, belief, intention) and sometimes emotion or mobility. They review representational and reasoning formalisms (modal logics for knowledge and belief, intention logics), critique their computational tractability, and survey implementations (AGENT-0, PLACA, Concurrent METATEM). The paper sets the vocabulary used by much subsequent MAS research.

Key Ideas

Three-way division: theory, architecture, language.
Weak vs. strong notion of agency.
Intentional stance justifies mentalistic ascription (Dennett/McCarthy).
BDI and related mental-state architectures.
Survey of 1990s agent languages and applications.

Connections

Conceptual Contribution

Claim: The emerging field of agent-based computing should be structured around the interlocking triad of agent theories, architectures and languages, and tensions between weak (behavioural) and strong (mentalistic) notions of agency should be kept explicit rather than elided.
Mechanism: Wooldridge and Jennings synthesise early 1990s work by (i) defining weak agency (autonomy, social ability, reactivity, pro-activeness) and strong agency (adds belief, desire, intention, emotion, mobility); (ii) surveying modal-logic theories of knowledge/belief/intention and the intentional stance as justification; (iii) cataloguing BDI, subsumption and layered architectures; and (iv) reviewing implemented languages (AGENT-0, PLACA, Concurrent METATEM) and representative applications. Computational tractability of the richer logics is flagged as a central open problem.
Concepts introduced/used: Weak Agency, Strong Agency, Intentional Stance, BDI, Subsumption Architecture, Layered Architecture, Concurrent METATEM, PLACA, Agent Theory-Architecture-Language Triad
Stance: survey
Relates to: Canonises the vocabulary used by Agent-Oriented Programming, Agent Communication Languages - Rethinking the Principles and Trends in Agent Communication Language; its tractability critique anticipates the social-semantic move in An Interaction-oriented Agent Framework for Open Environments.

Tags

Common Business Communication Language

The Common Business Communication Language

Reference: John McCarthy (1975/1982, revised 1998/1999). Stanford CS Department. Source file: cbcl2.pdf. URL

Summary

McCarthy’s 1975 memo (revived in 1998 with footnotes anticipating XML and electronic commerce) sketches a Common Business Communication Language (CBCL) allowing computers from different organizations to exchange business messages - requests for quotations, offers, order status, delivery queries - without pre-arranged bilateral formats. The paper enumerates requirements: open-endedness, pre-existing compatibility, independence of internal data formats, and ability to fall back to human-readable form when a receiver does not understand a new message.

He proposes messages as nested parenthesized lists (a Lisp-like syntax McCarthy argues is isomorphic to but simpler than XML), adjectival modifiers (ADJECTIVE FOO YELLOW), and Russell description operators for referring expressions. The essay prefigures KQML-style performatives and electronic data interchange, and closes with 1998 advice to XML, W3C, and ICE on extensibility, Lisp-style syntax, and standard time formats.

Key Ideas

Inter-organizational computer communication without pre-arranged formats.
Lisp-style S-expression syntax isomorphic to but simpler than XML.
Adjectival modifiers (ADJECTIVE x y as a kind of y) for partial understanding.
Non-monotonic reasoning required for natural-language-like expressivity.
Proto-KQML vision of semantic business messaging.

Connections

KQML
Agent Communication Languages
Three Models For The Description Of Language
Ontologies
Elephant 2000 - A Programming Language Based on Speech Acts — companion McCarthy proposal; CBCL messages are the inter-organisational counterpart of Elephant’s intra-program speech acts.
First Order Theories of Individual Concepts and Propositions — supplies the sense/denotation machinery CBCL tacitly relies on for descriptions.
Circumscription - A Form of Nonmonotonic Reasoning — the non-monotonic reading of ADJECTIVE and partial-understanding fallback rests on circumscription-style defaults.
Ascribing Mental Qualities to Machines
CBCL - Safe Self-Extending Agent Communication — O’Connor 2026 (LangSec ’26): Lean-verified contemporary realisation of this proposal.

Conceptual Contribution

Claim: Organisations should exchange business messages in a common, open-ended language without pre-arranged bilateral formats; partial understanding must degrade gracefully to human-readable fallback.
Mechanism: Lisp-style S-expression messages (isomorphic to but simpler than XML), adjectival modifiers (ADJECTIVE x y) for partial-match semantics, Russell description operators for referring expressions, non-monotonic reasoning for NL-like expressivity; 1998 footnotes advise XML/W3C/ICE communities.
Concepts introduced/used: Common Business Communication Language, S-expressions, EDI, Non-monotonic Reasoning, Adjectival Modifiers, Agent Communication Languages, Ontologies, Performatives, Speech Act Theory, KQML
Stance: foundational
Relates to: Anticipates the performative-based vision of KQML Language And Protocol and the open discovery ambitions of Agent Network Protocol / Survey Of Agent Interoperability Protocols; its syntactic minimalism resonates with REST’s uniform interface in Principled Design Of The Modern Web Architecture.

Tags

Deterministic Context-Free Language

The class of languages recognised by deterministic pushdown automata — equivalently, those generated by LR(k) grammars. DCFL is the minimal class above regular that supports nested structure (parentheses, envelopes, scoped sub-grammars) while guaranteeing parser equivalence: every conformant implementation produces exactly one parse tree for every input. General context-free grammars admit ambiguity and therefore parser-differential attacks; DCFLs do not. DCFL is the LangSec-recommended target class for protocol input languages: validity is decidable in linear time, recognisers are total, and the class is rich enough for nested message envelopes. DCFLs are not closed under union in general — a property that has to be sidestepped (e.g. by prefix-free dispatch tags) when designing self-extending protocols like CBCL - Safe Self-Extending Agent Communication.

In this vault

Precommitment

A distinguished state of a commitment object (Fornara & Colombetti 2002/2004) used to model the social situation a directive speech act sets up: because no agent can unilaterally place an obligation on another, a request from speaker a to hearer b creates a precommitment C(p, b, a, P|Q) whose debtor is the hearer. The hearer then either accepts (turning it into an active or conditional commitment), rejects (cancelling it), implicitly fulfils it by performing the requested action, or lets it expire after a time-out. Precommitment is what allows commitment-based ACL semantics to cover directives without retreating to mentalistic primitives.

In this vault

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

Event Calculus

A logic-based formalism (Kowalski & Sergot 1986; Shanahan’s planner formulation 2000) for reasoning about events that initiate and terminate fluents — properties whose truth value changes over time. Events are described by Initiates, Terminates, Happens, HoldsAt, Clipped, and Declipped predicates plus a small set of axioms.

In the agent-communication strand it is used to give an executable, planner-driven semantics to commitment-based protocols: each commitment is a fluent, each communicative act an event with Initiates/Terminates clauses, and protocol runs are abductively generated from initial- and goal-state descriptions.

In this vault

Flexible Protocol Specification and Execution

Flexible Protocol Specification and Execution: Applying Event Calculus Planning Using Commitments

Reference: Yolum, P. & Singh, M.P. (2002). Proceedings of the 1st International Joint Conference on Autonomous Agents and Multiagent Systems (AAMAS ’02), pp. 527–534. ACM, Bologna. Source file: yolum-singh-2002-flexible-protocol.pdf. URL

Summary

Yolum and Singh argue that finite-state-machine and Petri-net protocol formalisms over-constrain multi-agent interactions because they fix legal sequences of message tokens without regard to what those messages mean. They develop a commitment-based alternative in which each protocol action is reified as an operation on social commitments — Create, Discharge, Cancel, Release, Assign, Delegate — and the rules for how commitments evolve are formalised in a variant of the Event Calculus (Kowalski-Sergot, in Shanahan’s planner formulation). Base-level commitments C(x,y,p) and conditional commitments CC(x,y,p,q) become event-calculus fluents whose Initiates/Terminates clauses constitute the protocol specification.

The running example is the NetBill e-commerce protocol. Three reasoning postulates capture how a base-level commitment is discharged when its content holds, how a conditional commitment resolves into a base-level commitment when its precondition fires, and how CC is consumed when its consequent already holds. An abductive event-calculus planner (Shanahan) is then used to generate protocol runs from an initial state to a goal state, allowing agents to skip steps, reorder messages, or repair exceptions at runtime — provided every base-level commitment created during the run is eventually discharged. The result satisfies Singh’s three social-semantic desiderata: meaningful (content captured), verifiable (compliance checkable from public commitment trace), and declarative (specifies what each action achieves, not how to sequence actions).

Key Ideas

Commitment as fluent in event calculus: C(x,y,p) and CC(x,y,p,q) represented by the EC predicates Initiates, Terminates, HoldsAt, Happens, etc.
Six commitment operations (Create, Discharge, Cancel, Release, Assign, Delegate) compiled into Initiates/Terminates clauses.
Three postulates link content fluents to commitment fluents: discharging on content satisfaction, conditional-commitment resolution, and conditional consumption when consequent already true.
A protocol run is a sequence of Happens events; complete iff no base-level commitment is left holding — incomplete runs identify non-compliant agents.
Abductive planning (Shanahan) generates legal protocol runs from initial-state + goal-state descriptions, restoring autonomy/flexibility lost in FSM models.
Skipping steps and reordering (e.g. send-goods-before-accept) is supported because preconditions are over commitment state, not over a path through an FSM.
Permissions encoded via action preconditions; prohibitions encoded as commitments-not-to-bring-about.

Connections

Conceptual Contribution

Claim: Multi-agent protocols should be specified by the meaning of their actions — concretely, by how each action transforms the agents’ social commitments — rather than by legal token sequences; doing so simultaneously delivers meaningful, verifiable, and declarative semantics, and lets agents skip, reorder, or repair steps via runtime planning while still being held to their obligations.
Mechanism: Reify commitments as event-calculus fluents and define the six manipulation operations (Create/Discharge/Cancel/Release/Assign/Delegate) as Initiates/Terminates clauses; add three reasoning postulates governing base-level discharge and conditional-commitment resolution; use Shanahan’s abductive event-calculus planner to compute runs (sets of Happens clauses with a partial order) from initial states to goal states under the protocol’s preconditions; declare a run complete iff no base-level commitment is left holding, providing an objective compliance criterion.
Concepts introduced/used: Commitment, Conditional Commitment, Commitment-Based Protocol, Commitment-based Semantics, Event Calculus, Abductive Planning, Public Semantics, Verifiable Semantics, Conversation Protocols, Interaction Protocols, NetBill Protocol, Commitment Machines
Stance: formal-semantic / engineering
Relates to: Direct response to FSM- and Petri-net-based protocol traditions critiqued in ACL Rethinking Principles; supplies the operational machinery whose mentalistic counterpart (KQML/FIPA-SL) is shown unverifiable in Verifiable Semantics for ACLs. Companion to Singh’s social-agency programme and to the institutional-reality strand of Agent Communication And Institutional Reality. Conditional-commitment treatment derives from Colombetti’s earlier work and is contemporaneous with A Commitment-Based Approach to Agent Communication (Fornara & Colombetti AAMAS-02 / AAI-04), which gives a complementary object-oriented account of the same primitives (those authors note Yolum-Singh as the closest relative). Commitment-machine compilation to FSMs is the subject of the authors’ parallel ATAL-01 paper. Empire of mentalistic semantics from Intention Is Choice with Commitment is the foil — here intentions/persistence are not needed because the protocol semantics is exhausted by the public commitment trace.

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

Semantic Description For Agent Design Patterns

A Semantic Description For Agent Design Patterns

Reference: Sabatucci, Cossentino, Gaglio. AT2AI-08 / University of Palermo & ICAR-CNR. Source file: at2ai08_sabatucci.pdf. URL

Summary

The authors propose a fine-grained design language for formalizing and composing agent design patterns, integrated with the PASSI methodology for multi-agent system development. Patterns are represented as semantic networks (Pattern Semantic Description diagrams) whose nodes are Pattern Description Elements - participants, collaborators, events, and actions - typed against a MAS meta-model.

Four composition operators (Unification, Conjunction, Concealing, Externalization) let designers blend patterns systematically, preserving traceability of pattern contributions in the resulting structure. A worked example composes GenericAgent and Request patterns into SequentialShareResource, illustrating how FIPA-Request-compliant service agents can be built through pattern composition.

Key Ideas

PSD diagrams: semantic networks of Participants and Collaborators.
Composition operators: Unification, Conjunction, Concealing, Externalization.
Patterns typed against a MAS meta-model (agent, role, task, communication).
Integrated with PASSI design process.
Worked example of FIPA-Request service pattern composition.

Connections

Conceptual Contribution

Claim: Agent design patterns should be formalised as typed semantic networks with explicit composition operators, so that FIPA-compliant systems can be built by pattern algebra rather than ad-hoc composition.
Mechanism: Introduces Pattern Semantic Description (PSD) diagrams typed against a MAS meta-model; defines Unification, Conjunction, Concealing, and Externalization operators; integrates with the PASSI methodology; worked example composes GenericAgent + Request into SequentialShareResource.
Concepts introduced/used: Design Patterns, PASSI Methodology, MAS Meta-model, Pattern Composition, Interaction Protocols, Roles, FIPA-ACL, Agent-Oriented Programming, Ontologies, Multi-Agent Systems
Stance: engineering
Relates to: Supplies a pattern language for the protocol-level conversations tracked by ACRE Agent Conversation Reasoning Engine; its MAS meta-model leans on ontology foundations surveyed in Handbook On Ontologies.

Tags

Agent Communication And Institutional Reality

Agent Communication and Institutional Reality

Reference: Fornara, Viganò, Colombetti (2005). Agent Communication II, LNAI 3396, Springer. Source file: 978-3-540-32258-0_1.pdf. URL

Summary

Fornara, Viganò, and Colombetti propose regarding an Agent Communication Language as a set of conventions acting on a fragment of institutional reality, defined within an artificial institution. They reformulate commitment-based ACL semantics so that all commonly used communicative act types reduce to a single basic type, declarations, within a Basic Institution that regulates the lifecycle of social commitments.

Special institutions (e.g., English Auctions) extend the Basic Institution with ontological and normative elements. The approach is notable for making the semantics of speech acts publicly verifiable and independent of agents’ mental states, while retaining a uniform formal account of institutional actions and counts-as relations.

Key Ideas

ACL messages are institutional actions governed by counts-as rules.
Basic Institution manages creation/update/cancellation of social commitments.
All speech act types reducible to declarations within the institution.
Special institutions layer domain norms and ontologies on top.
English Auction given as worked example.

Connections

Conceptual Contribution

Claim: An ACL is best understood as a set of conventions operating on institutional reality; all communicative act types reduce to declarations within a Basic Institution that governs the lifecycle of social commitments.
Mechanism: Defines artificial institutions with counts-as rules; models message effects as declarations creating/updating/cancelling commitments; layers domain norms in Special Institutions (English Auction worked example).
Concepts introduced/used: Commitment-based Semantics, Institutional Reality, Counts-as Rules, Declarations, Performatives, Speech Act Theory, Public Semantics, Verifiable Semantics, Mentalistic Semantics, Ontologies, FIPA-ACL, Multi-Agent Systems
Stance: formal-semantic
Relates to: Offers the publicly-verifiable alternative to mental-state semantics of FIPA-ACL, which A Common Ontology Of ACLs then unifies via roles; grounded philosophically in Foundations Of Illocutionary Logic.

Tags

ACRE Agent Conversation Reasoning Engine

ACRE: Agent Conversation Reasoning Engine

Reference: Lillis & Collier (University College Dublin). Source file: ACRE_Agent_Conversation_Reasoning_Engine.pdf. URL

Summary

ACRE complements existing rule-based agent programming languages (AFAPL2, AgentSpeak, Jason, Jack) with explicit support for modelling, managing, and reasoning about complex multi-message conversations. Rather than handling each FIPA-ACL message individually, ACRE represents conversations as instances of protocols specified as Coloured Petri Nets or Dooley Graphs, so agents can track which performatives are expected next and react accordingly.

The paper integrates ACRE with the Agent Factory framework: conversations are exposed via a conversation-id parameter, and plan pre/postconditions in AFAPL2 reason over BELIEF(status(...)) predicates derived from ACRE. A Vickrey auction example shows how an Auctioneer agent uses ACRE-tracked conversations to issue cfp, collect propose/refuse messages, and broadcast accept-proposal/reject-proposal.

Key Ideas

Protocols are first-class citizens, separate from individual messages.
Conversations tracked via Coloured Petri Nets / Dooley Graphs.
Integration with AFAPL2: conversation state surfaces as beliefs for plan reasoning.
Code verification check that agent plans honour protocol expectations.
Vickrey auction case study using FIPA Contract Net-style interactions.

Connections

Conceptual Contribution

Claim: Agents need conversations, not just messages, as first-class abstractions; existing AOP languages (AgentSpeak, Jason, AFAPL2) lack native protocol reasoning.
Mechanism: Models FIPA-ACL interaction protocols as Coloured Petri Nets / Dooley Graphs instantiated per conversation-id; surfaces conversation state as BELIEF(status(...)) predicates usable in plan pre/postconditions; validated via Vickrey auction (Contract Net).
Concepts introduced/used: Interaction Protocols, Coloured Petri Nets, Dooley Graphs, Conversations, Conversation Policy, FIPA-ACL, Performatives, Contract Net Protocol, BDI, Agent-Oriented Programming, Multi-Agent Systems
Stance: engineering
Relates to: Operationalises the protocol-tracking needs implicit in FIPA-ACL and KQML; its plan-level conversation awareness is an ancestor of task/session tracking in modern Agent-to-Agent Protocol as covered by Survey Of Agent Interoperability Protocols.

Tags

Coordinating Agents Using ACL Conversations

Coordinating Agents using Agent Communication Languages Conversations

Reference: R. Scott Cost, Yannis Labrou, Tim Finin (2000). Springer-Verlag book chapter, March 2000. Source file: Coordinating_Agents_using_Agent_Communication_Lang.pdf. URL

Summary

This chapter argues that ACLs like KQML and FIPA-ACL provide the vocabulary for exchanging propositional attitudes but not the higher-level coordination structures agents need when carrying out task-oriented interactions. The authors advocate conversation protocols — pre-arranged message-exchange patterns — as the missing layer above individual speech acts, giving context for interpretation and enabling agents to expect and verify sequences of messages.

They survey existing approaches (COOL state machines, Dooley Graphs, Push-Down Transducers, DCGs) and propose a formalism based on Colored Petri Nets (CPNs) for specifying conversation protocols. The CPN-based specification enables concurrency modeling, role/participant tracking, and formal verification of properties like liveness and reachability. The approach positions shareable conversation protocol specifications as “abstract agent interfaces” (AAIs).

Key Ideas

ACLs alone do not encode expectations about response sequences; conversation protocols fill that gap.
Conversation = pre-arranged coordination protocol giving pragmatic context to messages.
Colored Petri Nets offer concurrency and verifiability lacking in FSM-based approaches.
Three issues for conversations: specification, sharing, and aggregation into services.
Specialization and composition of conversations, analogous to OO subclassing.

Connections

Conceptual Contribution

Claim: Isolated speech-act messages are insufficient for agent coordination; shareable, verifiable conversation protocols — best specified as Colored Petri Nets — are the appropriate layer above ACL performatives.
Mechanism: Survey of FSM/DFA/DCG conversation models (COOL, Dooley Graphs, ATM, PDTs) and their expressivity limitations; stepwise translation of a KQML Register conversation from JDFA to an equivalent CPN that captures role constraints, concurrency, message ordering, and a negotiation example; argues CPNs enable liveness/reachability verification.
Concepts introduced/used: Conversation Protocols, Colored Petri Nets, Propositional Attitudes, Abstract Agent Interfaces, Conversation Specialization, Conversation Composition, Speech Acts
Stance: engineering / formal-semantic
Relates to: Complements ACRE Agent Conversation Reasoning Engine (runtime reasoning over conversation state) and shares motivation with Verifiable Semantics for ACLs — both insist ACL semantics be externally checkable. Builds on KQML Overview and FIPA-ACL performative sets.

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

Towards Automating the Evolution of Linguistic Competence

Towards Automating the Evolution of Linguistic Competence in Artificial Agents

Reference: Gmytrasiewicz, P. J., Gopal, D. (2000). Technical article, University of Texas at Arlington. Source file: Towards_Automating_the_Evolution_of_Linguistic_Com.pdf. URL

Summary

Gmytrasiewicz and Gopal propose a decision-theoretic framework for artificial agents to autonomously enrich and evolve their shared agent communication language. Each agent has a frame/object-based knowledge representation language (KRL) encoding beliefs about the world and nested beliefs about other agents. Decisions about which messages to send are grounded in expected-utility computations over the effect on the hearer’s mental state, so every well-defined message carries measurable value to the speaker.

When the ACL proves inadequate to express content the agent wishes to communicate, the agents engage in game-theoretic negotiation (after Rubinstein-style alternating offers) over new lexicon items and grammatical rules. Utilities trade off implementation cost, time-discounting, and communicative gain. The framework thus gives a concrete mechanism for pidgin-like emergence of shared ACLs among rational, knowledge-based agents.

Key Ideas

KRL as agents’ “language of thought”; ACL is a translation target.
Message value = expected-utility impact on hearer’s mental state.
Negotiation over lexicon and grammar when ACL is insufficient.
Nested agent models enable rational communication choices.
Decision-theoretic, game-theoretic grounding for language emergence.

Connections

Conceptual Contribution

Claim: The content and extension of an agent communication language can be derived from rational-decision principles: every message carries measurable expected utility, and when the current ACL is insufficient, agents rationally negotiate new lexicon and grammar.
Mechanism: Each agent has a frame-based KRL representing nested beliefs about others; message utility is computed as the expected change in the hearer’s mental state weighed against action value. When no existing ACL expression suffices, Rubinstein-style alternating-offers bargaining over new lexicon items and grammar rules trades off implementation cost, time-discount, and future communicative gain, producing a pidgin-like convergence path.
Concepts introduced/used: Knowledge Representation Language, Expected Utility Communication, Rubinstein Bargaining, Nested Beliefs, Lexicon Negotiation, Pidgin Emergence, Decision-Theoretic ACL
Stance: formal-semantic
Relates to: Provides a decision-theoretic counterpart to the situated emergence of Language Games for Autonomous Robots and the neural emergence studied in On the Pitfalls of Measuring Emergent Communication; its utility-grounded messages contrast with the mentalistic sincerity conditions of Agent-Oriented Programming and FIPA-ACL.

Tags

Toward Automated Evolution of ACLs

Toward Automated Evolution of Agent Communication Languages

Reference: Piotr J. Gmytrasiewicz, Matthew Summers, Dhruva Gopal (2001). AAAI (American Association for Artificial Intelligence). Source file: gmytrasiewicz02towardAutomated.pdf. URL

Summary

Instead of designing ACLs centrally (like KQML or FIPA), the authors propose letting rational, self-interested agents evolve a shared ACL on the fly when they encounter each other. Each agent has its own internal knowledge representation language (KRL) and decides, via Bayesian decision theory and expected-utility calculations, which messages are worth sending and which new ACL constructs are worth negotiating into the shared vocabulary.

Language creation is modeled as a negotiation game drawing on Rubinstein bargaining: agents propose grammatical rules and terminal labels, weigh them against translation/implementation costs and the value of faster communication, and reach Nash-equilibrium agreements. They illustrate with a Wumpus-world scenario, showing how pidgin ACLs grow into richer creole-like languages via unsupervised learning of transducers and negotiation of new lexicon/grammar productions.

Key Ideas

ACL emerges from pairwise negotiation instead of top-down standardization.
Rational agents use expected-utility gains from communication to drive language extension.
Translator modeled as a finite-state transducer between KRL and ACL.
Rubinstein bargaining gives closed-form agreement on new ACL constructs.
Evolution from pidgin to creole through repeated interaction.

Connections

Conceptual Contribution

Claim: Agent communication languages need not be standardised top-down (KQML, FIPA); rational agents can initiate, enrich, and evolve a shared ACL through game-theoretic negotiation driven by expected-utility gains from improved communication.
Mechanism: Each agent owns a private KRL and a finite-state transducer translating KRL ↔ ACL; decision-theoretic message selection (Bayesian, utility-maximising) identifies candidate new lexical/grammatical constructs; a Rubinstein-bargaining model with time discounting, implementation cost, and identity assumptions yields Nash-equilibrium agreements that extend the shared ACL grammar. Illustrated on a Wumpus-world example.
Concepts introduced/used: ACL Evolution, Knowledge Representation Language, Finite-State Transducer, Rubinstein Bargaining, Pidgin and Creole, Value of Communication, Unsupervised Grammar Induction, Mechanism Design
Stance: formal-semantic / engineering
Relates to: Offers a decentralised alternative to the standardisation stance of KQML Overview and FIPA-ACL; resonates with Emergence of Grounded Compositional Language in Multi-Agent Populations and Emergent Communication which study language emergence from interaction; the bargaining apparatus parallels commitment-based approaches in Agent Communication And Institutional Reality.

Tags

A Common Ontology Of ACLs

A Common Ontology of Agent Communication Languages: Modeling Mental Attitudes and Social Commitments using Roles

Reference: Boella, Damiano, Hulstijn, van der Torre (2006). Applied Ontology 3(1-3). Source file: ao07b.pdf. URL

Summary

The authors propose a common ontology that bridges two dominant semantic traditions for Agent Communication Langua mental-attitude-based semantics (FIPA-ACL) and social-commitment-based semantics (Singh, Colombetti). The unifying device is the role: each agent plays role instances in dialogue sessions, and both beliefs/intentions and commitments are attributed to role instances rather than to private mental states, sidestepping the unverifiability problem.

They develop Role-SL, a BDI logic extended with roles and dialogue sessions, and show translation schemes from FIPA speech acts and from actioandopositional commitment semantics into this role-based ontology. The framework accommodates mixed dialogues (e.g., persuasion intertwined with negotiation) that neither tradition handles cleanly alone.

Key Ideas

Roles as first-class carriers of public mental attitudes.
Role-SL: extension of FIPA-SL with role instances and dialogue sessions.
Mappings from FIPA-ACL and commitment-based ACLs into one ontology.
Public beliefs/intentions sidestep mental-state unverifiability.
Distinguishes action commitments (request/propose) from propositional (assert/challenge).

Connections

Conceptual Contribution

Claim: Mental-attitude and social-commitment ACL semantics can be unified under a common ontology by attributing both to roles instantiated in dialogue sessions, rather than to private agent minds.
Mechanism: Extends FIPA-SL into Role-SL (BDI + roles + dialogue sessions); provides translation schemes from FIPA speech acts and from action/propositional commitment semantics; handles mixed dialogues (persuasion + negotiation).
Concepts introduced/used: Roles, BDI, Commitment-based Semantics, Mental Attitudes, Mentalistic Semantics, Public Semantics, Verifiable Semantics, Dialogue Sessions, FIPA-ACL, Speech Act Theory, Ontologies, Agent Communication Languages
Stance: formal-semantic
Relates to: Bridges the two traditions typified by FIPA-ACL (mentalist) and Agent Communication And Institutional Reality (commitment-based); uses ontology machinery catalogued in Handbook On Ontologies.

Tags

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 - A Language And Protocol For Knowledge And Information Exchange

KQML - A Language and Protocol for Knowledge and Information Exchange

Reference: Finin, Fritzson, McKay, McEntire (1994). AAAI Technical Report WS-94-02, Workshop on Knowledge-Based Collaboration Systems. Source file: WS94-02-007.pdf. URL

Summary

This is one of the canonical early KQML papers, describing the Knowledge Query and Manipulation Language as both a message format and a message-handling protocol for run-time knowledge sharing among intelligent agents. Developed as part of the ARPA Knowledge Sharing Effort (KSE), KQML is presented as an enabling technology for building large-scale, sharable, reusable knowledge bases and for letting independently developed systems interoperate at the knowledge level rather than at the level of raw RPC or ad-hoc protocols.

The paper introduces the core architectural commitments of KQML: an extensible set of performatives (reserved speech-act-like operations that agents perform on each other’s knowledge and goal stores), a three-layer message structure (content, message/communication, and communication mechanics), and a special class of facilitator agents that coordinate interactions and provide services such as brokering, recruitment, and content-based routing. Performatives fall into seven categories (basic query, multi-response query, response, generic informational, generator, capability-definition, networking) including ask-one, ask-all, tell, untell, achieve, subscribe, advertise, broker, recommend, and recruit.

The authors sketch KQML’s semantics informally in terms of effects on an agent’s belief and intention stores (e.g., tell(S) is an assertion by the sender that S is in its virtual belief store; achieve(S) asks the recipient to add S to its intention store), and note ongoing work on formal semantics via definite clause grammars and on interoperability with KIF and Ontolingua ontologies.

Key Ideas

KQML as both message format and message-handling protocol; focused on pragmatics, secondarily on semantics.
Three-layer message structure: content, communication/message, communication mechanics.
Extensible performative set organized into seven categories.
Facilitator agents: brokers, matchmakers, recruiters, content-based routers.
Synchronous, asynchronous, streaming, and subscription interaction protocols.
Performatives as speech-act-like operations on agents’ belief and goal stores.
Integration with KIF for content and shared ontologies for semantic grounding.
Part of the ARPA Knowledge Sharing Effort (KSE): Interlingua, KRSS, SRKB, External Interfaces working groups.

Connections

Conceptual Contribution

Claim: Heterogeneous intelligent systems can share knowledge at run time if they agree on a protocol of speech-act-like performatives over a common content language and shared ontology, coordinated by specialized facilitator agents.
Mechanism: Defines an extensible parenthesized message syntax with reserved performative names and keyword/value arguments; layers communication (sender/receiver/identifier), message (performative, ontology, language), and content; routes messages through facilitators that implement brokering, matchmaking, and content-based subscription; gives informal speech-act semantics in terms of effects on virtual belief and intention stores.
Concepts introduced/used: KQML, Performatives, Facilitator Agents, KIF, Speech Act Theory, Ontologies, Agent Communication Languages
Stance: foundational
Relates to: One of the defining sources for KQML and Agent Communication Languages in this vault; direct precursor to FIPA-ACL; establishes the performative/speech-act framing critiqued and refined in ACL Design Principles, ACL Rethinking Principles, and Agent Communication Languages - Rethinking the Principles; the facilitator concept informs Agent Discovery and Agent Hub patterns.

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

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

KQML Language And Protocol

KQML - A Language and Protocol for Knowledge and Information Exchange

Reference: Finin, Fritzson, McKay, McEntire (1994). AAAI Technical Report WS-94-02 (ARPA Knowledge Sharing Effort). Source file: 741.pdf. URL

Summary

This paper describes the design of the Knowledge Query and Manipulation Language (KQML), an agent communication language developed under the ARPA Knowledge Sharing Effort. KQML is both a message format and a message-handling protocol supporting run-time knowledge sharing among cooperating intelligent agents. Its core contribution is an extensible set of performatives (speech-act-style operations such as tell, ask-if, ask-all, subscribe, advertise, broker, recruit) that define what an agent may do with another agent’s knowledge and goal stores.

KQML is organised as three layers - content, message, and communication - where the message layer carries a performative and metadata while the content layer is treated as opaque (often KIF). The paper introduces facilitators - special agents that coordinate others via content-based routing, brokering, recruiting, and matchmaking - and describes KRILs (KQML Router Interface Libraries) for embedding KQML into Lisp, Prolog, C, and SQL applications.

Key Ideas

Performative-based messaging grounded in speech act theory.
Three-layer architecture: content, message, communication.
Facilitators for content-based routing, brokering, recruiting.
KRILs as embedding libraries for existing systems.
Prototype uses: ARPA Rome Planning Initiative, CAD/CAM, intelligent databases.

Connections

Conceptual Contribution

Claim: Knowledge sharing among heterogeneous intelligent agents is best realised by a layered, performative-based message protocol whose content is opaque and whose routing is mediated by special facilitator agents.
Mechanism: Defines a three-layer architecture (content / message / communication), a set of extensible performatives grounded in Speech Act Theory, facilitators for brokering/recruiting/matchmaking, and KRIL embedding libraries for Lisp/Prolog/C/SQL.
Concepts introduced/used: KQML, Performatives, Facilitators, Content Languages, KIF, Speech Act Theory, Ontologies, Multi-Agent Systems, Agent Communication Languages
Stance: foundational / engineering
Relates to: Direct philosophical descendant of Foundations Of Illocutionary Logic and sibling proposal to Common Business Communication Language; becomes the ancestor that FIPA-ACL, Agent Communication And Institutional Reality, A Common Ontology Of ACLs, and the modern surveys (Survey Of AI Agent Protocols, Survey Of Agent Interoperability Protocols) all build on or critique.

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

Cicero Human-Level Play in Diplomacy

Human-Level Play in the Game of Diplomacy by Combining Language Models with Strategic Reasoning (Cicero)

Reference: Meta Fundamental AI Research Diplomacy Team (FAIR), Anton Bakhtin, Noam Brown, Emily Dinan, Gabriele Farina, Colin Flaherty, Daniel Fried, Andrew Goff, Jonathan Gray, Hengyuan Hu, et al. (2022). Science 378(6624):1067–1074. Source file: downloads/cicero.pdf. URL

Summary

Presents Cicero, the first AI to reach human-level performance in the no-press-restricted, seven-player, natural-language negotiation game of Diplomacy. The system couples a controllable dialogue model with a planning-and-reinforcement-learning engine: the planner computes intended actions for Cicero and its opponents using regret-minimisation and a value network; the dialogue model is then conditioned on those intentions to generate messages that are simultaneously strategically grounded, honest-by-construction with respect to the chosen plan, and stylistically indistinguishable from human play.

Cicero infers other players’ beliefs and intentions from their messages and prior actions, filters candidate utterances through classifiers trained to reject nonsense / inconsistent / ungrounded lines, and commits to moves consistent with what it said. Across 40 online games it more than doubled the average human score and ranked in the top 10% of repeat players — the strongest demonstration to date that language models can carry out intentional, strategically grounded communication with humans in a mixed cooperation/competition environment.

Key Ideas

Grounded dialogue: natural-language messages conditioned on explicit planned intents
Regret-minimisation planner with neural value function jointly optimises for Cicero and opponents
Intent inference: read beliefs/plans from incoming dialogue, fold into the planner
Multi-stage message filtering (nonsense, inconsistency, grounding, value) to enforce honesty and stylistic naturalness
First demonstration of human-level performance in a language-negotiation strategy game

Connections

Conceptual Contribution

Claim: Intentional, honest, strategically grounded natural-language communication between an AI and humans is achievable by explicitly separating the planning layer (what to do) from the dialogue layer (what to say), and conditioning the latter on the former with heavy filtering — rather than hoping a pure language model will learn strategic intent end-to-end.
Mechanism: An intent-conditioned dialogue model is trained on human Diplomacy games with extracted action annotations. At play time, a piKL-based planner runs regret minimisation over candidate joint actions using a neural value network; Cicero’s chosen intent is fed to the dialogue model. Generated messages pass through nonsense/consistency/grounding/value filters and a final policy check that the outgoing message is consistent with Cicero’s actually intended move. Incoming messages are parsed into inferred opponent intents that feed back into the planner.
Concepts introduced/used: LLM Agents, Negotiation, Joint Intentions, intent-conditioned generation, regret minimisation / piKL, Cheap Talk, Honesty Constraint, Grounding
Stance: empirical / machine learning
Relates to: Cited in A Scalable Communication Protocol for Networks of LLMs as an exemplar of LLM-mediated negotiation between autonomous agents — Agora pushes the same idea from a closed seven-player game into an open, decentralised network and from ad-hoc utterances to hash-addressed Protocol Documents. Instantiates the speech-act / sincerity-condition programme of Foundations Of Illocutionary Logic and Sincerity Condition inside a modern deep-learning agent. Contrasts with emergent-language approaches like Multi-Agent Cooperation and the Emergence of Natural Language by using a pretrained human-language model.

Tags

The Rise and Potential of LLM-Based Agents

The Rise and Potential of Large Language Model Based Agents: A Survey

Reference: Xi, Chen, Guo, He, Ding, Hong, Zhang, Wang, Jin, Zhou, Zheng, Fan, Wang, Xiong, Zhou, Wang, Jiang, Zou, Liu, Yin, Dou, Weng, Cheng, Zhang, Qin, Zheng, Qiu, Huang, Gui (2023). Fudan NLP Group, arXiv preprint. Source file: 2309.07864.pdf. URL

Summary

A comprehensive survey of LLM-based agents organised around a three-component conceptual framework — brain, perception, action — that the authors propose as a general template for agent construction. The brain covers natural-language interaction, knowledge, memory, reasoning/planning, and transferability; perception covers textual, visual, auditory, and other inputs; action covers textual output, tool use, and embodied action.

The survey then examines agents in practice (single-agent task/innovation/lifecycle deployments; multi-agent cooperative and adversarial interaction; human-agent instructor-executor and equal-partnership paradigms) and agent societies (personality, social behaviour, environments, society simulation, ethical/social risks). A final discussion chapter covers evaluation, adversarial robustness, trustworthiness, scaling the number of agents, and open problems — directly feeding the threat taxonomy of AI Agents Under Threat.

Key Ideas

Brain/perception/action triad as a unifying architecture for LLM agents.
Single-agent vs multi-agent vs human-agent deployment axes.
Cooperative complementarity and adversarial advancement as the two poles of multi-agent interaction.
Agent society simulation (à la Generative Agents) as both a scientific instrument and a risk surface.
Dedicated treatment of adversarial robustness and trustworthiness as first-class concerns in agent design.

Connections

Conceptual Contribution

Claim: LLM-based agents should be understood through a unified brain/perception/action framework, with deployments spanning single-agent, multi-agent, and human-agent configurations, and societies displaying emergent social phenomena that demand first-class security and trustworthiness analysis.
Mechanism: Literature synthesis organised around the three-component architecture, three deployment paradigms, and an agent-society lens; taxonomy of cooperative vs adversarial multi-agent interaction; catalogue of open problems in robustness, trustworthiness, and scaling.
Concepts introduced/used: brain/perception/action triad, instructor-executor vs equal-partnership paradigms, agent society, adversarial robustness, Tool Use, Multi-Agent Systems, LLM Agents.
Stance: survey
Relates to: The brain/perception/action decomposition directly informs the perception/brain/action threat axes used by AI Agents Under Threat; multi-agent cooperation analysis motivates ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems and the inter-agent risks catalogued in SoK The Attack Surface of Agentic AI.

Tags

Generative Agents

Generative Agents: Interactive Simulacra of Human Behavior

Reference: Park, O’Brien, Cai, Morris, Liang, Bernstein (2023). UIST ’23. Source file: 2304.03442.pdf. URL

Summary

Introduces generative agents: LLM-powered simulacra that populate a Sims-like sandbox with 25 characters who wake, plan their day, converse, form opinions, remember past events, reflect, and coordinate group activities (e.g., autonomously spreading invitations to a Valentine’s Day party). The agent architecture extends an LLM with three components: a memory stream (natural-language log of experiences with recency/importance/relevance retrieval), reflection (higher-level inferences synthesised from memories), and planning (recursive decomposition of daily goals into action sequences), with reflections and plans fed back into the memory stream.

The paper is a widely-cited foundational reference for agent memory and social simulation, and is invoked throughout AI Agents Under Threat as the canonical multi-agent LLM society whose emergent behaviours define the attack surface for Memory Poisoning and inter-agent risks.

Key Ideas

Memory stream as a long-term, natural-language, retrieval-indexed experience log.
Retrieval scoring combines recency, importance, and semantic relevance.
Reflection: periodic self-prompted synthesis of memories into higher-level beliefs, propositions, and abstractions.
Planning: top-down decomposition of daily goals into hierarchical schedules that feed back into memory.
Believable individual and emergent group behaviour (information diffusion, relationship formation, coordination) arising without scripted dialogue trees.

Connections

Conceptual Contribution

Claim: Believable long-horizon human-like behaviour in LLM agents can be produced by augmenting the model with an architectural trio — memory stream, reflection, planning — that together let the agent retrieve, generalise, and act over long time horizons.
Mechanism: Natural-language memory stream with recency+importance+relevance retrieval; periodic reflection that distils memories into higher-level beliefs; recursive top-down planning that writes plans back into memory; all components implemented as LLM prompts over ChatGPT.
Concepts introduced/used: memory stream, reflection, recursive planning, believable simulacra, emergent social dynamics — the substrate for Memory Poisoning and inter-agent cascade attacks in AI Agents Under Threat and ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems.
Stance: constructive/empirical
Relates to: Establishes the memory+reflection+planning template whose failure modes are analysed in AI Agents Under Threat (brain/memory threats) and whose emergent multi-agent phenomena motivate Multi-Agent Systems security work.

Tags

Language Models are Few-Shot Learners

Reference: Brown, Mann, Ryder, Subbiah, Kaplan, Dhariwal, Neelakantan, Shyam, Sastry, Askell et al. (2020). NeurIPS 2020. Source file: 2005.14165.pdf. URL

Summary

Introduces GPT-3, a 175-billion-parameter autoregressive Transformer language model, and shows that scaling up enables task-agnostic few-shot learning purely through in-context demonstrations — no gradient updates or fine-tuning required. The paper establishes the empirical basis for the “prompt as interface” paradigm that underpins modern LLM Agents.

GPT-3 is evaluated across dozens of NLP benchmarks (translation, QA, cloze, Winograd, arithmetic, word unscrambling, SuperGLUE, NLI) in zero-, one-, and few-shot regimes, often matching or exceeding state-of-the-art fine-tuned systems. The authors also examine broader impacts: misuse potential, bias, fairness, and energy cost — topics that later crystallise into the threat surfaces surveyed in AI Agents Under Threat.

Key Ideas

Scaling laws: performance on downstream tasks improves smoothly with model size, compute, and data.
In-context learning: a “meta-learning” inner loop where the model adapts to a task from examples in its prompt window, without weight updates.
Few-shot prompting as a general interface: the prompt becomes the programmable surface for LLM behaviour — the same surface later exploited by Prompt Injection and Jailbreak attacks.
Emergent capabilities (arithmetic, novel-word use) appearing only at scale.
Early catalogue of misuse risks (disinformation, generated news indistinguishable from human-written) foreshadowing agent-era threats.

Connections

Conceptual Contribution

Claim: Sufficiently large autoregressive language models become few-shot learners, performing new tasks from prompt demonstrations alone — establishing the prompt as the universal programming surface for LLM systems.
Mechanism: Train a 175B-parameter Transformer on ~300B tokens of filtered Common Crawl, WebText2, Books, and Wikipedia; evaluate on 40+ benchmarks in zero/one/few-shot settings without gradient updates.
Concepts introduced/used: in-context learning, few-shot prompting, scaling laws, emergent capabilities, prompt-as-interface — all prerequisites for LLM Agents, Tool Use, Prompt Injection, and the threat taxonomy of AI Agents Under Threat.
Stance: empirical/position
Relates to: Foundational substrate cited throughout AI Agents Under Threat; the prompt interface it popularises is the attack surface studied in Prompt Injection, Jailbreak, and ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems.

Tags

Chain-of-Thought Prompting

Chain-of-Thought Prompting Elicits Reasoning in Large Language Models

Reference: Wei, Wang, Schuurmans, Bosma, Ichter, Xia, Chi, Le, Zhou (2022). NeurIPS 2022. Source file: 2201.11903.pdf. URL

Summary

Shows that prompting a sufficiently large language model with a few exemplars that include intermediate natural-language reasoning steps — a chain of thought — dramatically improves performance on arithmetic, commonsense, and symbolic reasoning benchmarks. The technique requires no finetuning, no verifiers, and no task-specific training data beyond a handful of (input, chain-of-thought, output) triples.

Prompting PaLM-540B with eight chain-of-thought exemplars achieves then-state-of-the-art accuracy on GSM8K math word problems, surpassing even a finetuned GPT-3 with a verifier. Gains emerge only at scale (~100B parameters), making CoT one of the canonical examples of emergent capability. CoT underpins most modern agent reasoning loops (ReAct, ToT, Reflexion, LLM-Planner) referenced throughout AI Agents Under Threat and LLM Agents.

Key Ideas

A prompt of input/rationale/output triples unlocks multi-step reasoning without any parameter updates.
CoT is emergent: negligible benefit below ~100B parameters, striking gains above.
Works across arithmetic, commonsense, and symbolic domains — the method is task-general.
Rationale generation enables interpretability windows and lays the groundwork for reasoning-trace auditing in agent security.
The externalised reasoning trace is itself an attack surface — later exploited by indirect Prompt Injection and adversarial rationale manipulation.

Connections

Conceptual Contribution

Claim: Providing a small number of exemplars with explicit intermediate reasoning steps in the prompt elicits multi-step reasoning in sufficiently large language models, yielding state-of-the-art performance without finetuning.
Mechanism: Few-shot prompt template ⟨input, chain-of-thought rationale, output⟩; the model learns to generate its own rationales before the final answer at inference time.
Concepts introduced/used: chain-of-thought prompting, emergent reasoning, prompt-only adaptation — the substrate for ReAct-style agent loops that structure LLM Agents and the reasoning traces attacked in AI Agents Under Threat.
Stance: empirical
Relates to: The reasoning-trace paradigm CoT popularises is the target of Prompt Injection, goal-hijacking jailbreaks, and the brain-layer threats catalogued in AI Agents Under Threat.

Tags

Toolformer

Toolformer: Language Models Can Teach Themselves to Use Tools

Reference: Schick, Dwivedi-Yu, Dessì, Raileanu, Lomeli, Zettlemoyer, Cancedda, Scialom (2024). NeurIPS 2023. Source file: 2302.04761.pdf. URL

Summary

Toolformer shows that a language model can teach itself, in a self-supervised way, to decide when to call an external API, which API to call, what arguments to pass, and how to incorporate the returned result into subsequent token prediction. Starting from a handful of human-written demonstrations per tool, the model annotates a large corpus with candidate API calls, executes them, and keeps only the calls whose results reduce the cross-entropy loss on the surrounding tokens. The filtered, API-augmented corpus is then used to finetune the model.

The approach is demonstrated on a calculator, Q&A system, Wikipedia search, machine translation, and calendar. A 6.7B Toolformer (GPT-J-based) outperforms a much larger GPT-3 on several zero-shot downstream tasks without sacrificing core language modelling. The paper is a foundational reference for Tool Use in LLM Agents and therefore for the tool-layer attack surface catalogued in AI Agents Under Threat and MalTool Malicious Tool Attacks.

Key Ideas

Self-supervised tool learning via loss-reduction filtering — no task-specific supervision.
API calls are represented as interleaved special tokens (<API> name(args) -> result </API>) directly inside the token stream.
A single model learns heterogeneous tools rather than one tool per specialist.
Tools compensate for LLM weaknesses (arithmetic, factual recall, freshness, low-resource translation).
Establishes the architectural template — model emits tool-call tokens, external executor returns results, tokens resume — that later MCP/A2A-style protocols generalise.

Connections

Conceptual Contribution

Claim: Language models can learn to use external tools in a self-supervised fashion by keeping only API calls whose responses reduce next-token loss, bootstrapping tool competence from a handful of demonstrations.
Mechanism: Sample candidate API-call positions and arguments via in-context prompting; execute calls; filter by weighted cross-entropy reduction (L_i^- − L_i^+ ≥ τ_f); finetune on the filtered, API-interleaved corpus.
Concepts introduced/used: self-supervised tool learning, API-call tokens, loss-based filtering, Tool Use, LLM Agents — the direct antecedent of Model Context Protocol style tool-calling interfaces.
Stance: constructive
Relates to: Supplies the tool-invocation substrate whose abuses are studied in MalTool Malicious Tool Attacks, Skill Supply Chain Attack, and the action-layer threats in AI Agents Under Threat.

Tags

MCP Landscape Security Threats And Future Research Directions

Model Context Protocol (MCP): Landscape, Security Threats, and Future Research Directions

Reference: Hou, Zhao, Wang, Wang (2025). Huazhong University of Science and Technology. arXiv:2503.23278. Source file: 2503.23278.pdf. URL

Summary

The first in-depth academic analysis of the Model Context Protocol (MCP) ecosystem. The authors trace the evolution from manual API wiring through OpenAI plugins and framework-specific tool abstractions (LangChain, LlamaIndex) to Anthropic’s MCP, which they characterise as a protocol-level standard that decouples tool implementation from usage, enabling dynamic discovery, bi-directional channels, and schema negotiation.

Beyond the ecosystem survey, the paper contributes a systematic threat taxonomy: four attacker archetypes (malicious developers, external attackers, malicious users, security flaws) and 16 concrete threat scenarios spanning creation, deployment, operation, and maintenance of MCP servers. Real-world case studies validate the threat model against current servers, and the authors outline governance and scalability directions for MCP’s sustainable growth.

Key Ideas

MCP as the first post-function-calling protocol standard for LLM tool access (vs platform-specific plugins).
Lifecycle model for MCP servers: creation, deployment, operation, update, termination.
Four attacker archetypes: malicious developers, external attackers, malicious users, security flaws.
16 threat scenarios including tool poisoning, installer spoofing, unauthorized access.
Bi-directional communication channels distinguish MCP from one-way plugin interfaces.
Remaining gaps: security, tool discoverability, remote deployment, governance.

Connections

Model Context Protocol
Survey Of Agent Interoperability Protocols
Survey Of AI Agent Protocols
LLM Agents
Tool Use
AI Agents Under Threat
MalTool Malicious Tool Attacks
Agent Security
CBCL - Safe Self-Extending Agent Communication — structural alternative: a DCFL-bounded ACL with formally-checked self-extension, addressing the unbounded-input-language problem that underlies MCP’s threat surface.

Conceptual Contribution

Claim: MCP represents a qualitative shift from hardcoded, per-application tool bindings to a composable, discoverable ecosystem of AI-native web services — but its rapid adoption has outrun academic analysis of its architecture, lifecycle, and security posture.
Mechanism: Combines an architectural decomposition (host/client/server) and a five-phase server lifecycle with a threat-modelling exercise across 16 scenarios and 4 attacker archetypes, grounded in real MCP servers surveyed in the wild.
Concepts introduced/used: Model Context Protocol, Tool Use, Agent Security, LLM Agents, Interoperability, Agent Discovery
Stance: survey / threat analysis
Relates to: Deepens the MCP security discussion sketched in Survey Of Agent Interoperability Protocols and Survey Of AI Agent Protocols; its threat taxonomy complements MalTool Malicious Tool Attacks and AI Agents Under Threat by focusing specifically on the MCP protocol surface rather than individual tools.

Tags

MetaGPT Meta Programming for Multi-Agent Collaboration

MetaGPT: Meta Programming for a Multi-Agent Collaborative Framework

Reference: Sirui Hong, Mingchen Zhuge, Jiaqi Chen, Xiawu Zheng, Yuheng Cheng, Ceyao Zhang, Jinlin Wang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, Chenyu Ran, Lingfeng Xiao, Chenglin Wu, Jürgen Schmidhuber (2024). ICLR 2024. Source file: downloads/metagpt.pdf. URL

Summary

Proposes a multi-agent LLM framework that encodes human Standard Operating Procedures (SOPs) — the waterfall-style division of labour used in software companies — directly into the agent protocol. Agents are assigned concrete professional roles (Product Manager, Architect, Project Manager, Engineer, QA) and communicate not through free-form chat but through structured artefacts (PRD, system design, API spec, task list, code, test report). Each artefact has a fixed schema that the downstream role consumes.

To curb hallucination and long-horizon error compounding, MetaGPT introduces an executable feedback mechanism: generated code is executed, failures are fed back to the Engineer role, and edits iterate until tests pass. On HumanEval, MBPP, and an in-house software-generation benchmark, MetaGPT substantially outperforms single-agent and unstructured multi-agent baselines, establishing structured-artefact communication as a practical antidote to cascading hallucination in agent collectives.

Key Ideas

Encode human SOPs as the coordination protocol for LLM agents
Message-passing over structured artefacts (PRD, design, API spec, code) rather than free chat
Publish-subscribe shared message pool + role-based subscription filter
Executable feedback loop for self-correcting code generation
First multi-agent LLM framework to ship end-to-end software from a one-line requirement

Connections

Conceptual Contribution

Claim: Free-form natural-language chat is the wrong coordination medium for LLM agent collectives; encoding human SOPs and requiring communication via structured, role-specific artefacts dramatically reduces hallucination compounding and enables reliable multi-step software generation.
Mechanism: Agents are typed by professional role with role-specific prompts and tools. Communication flows through a shared message pool with a subscription filter so each role sees only artefacts relevant to it. Each stage emits a schema-constrained artefact consumed by the next. An executable feedback subsystem runs the generated code, captures failures, and loops them back to the Engineer role for targeted repair.
Concepts introduced/used: Standard Operating Procedures (SOPs), Roles, LLM Agents, publish-subscribe message pool, structured artefact communication, executable feedback, Protocol Documents
Stance: engineering / empirical
Relates to: Directly cited by A Scalable Communication Protocol for Networks of LLMs as an example of rigid, hand-designed inter-agent protocols — Agora’s negotiated Protocol Documents can be seen as a dynamic, decentralised generalisation of MetaGPT’s fixed SOP artefacts. Shares the structured-artefact intuition with FIPA-ACL and KQML as an Agent Communication Language, but grounds it in LLM-generatable schemas rather than stipulated performatives. Contrast with the free-dialogue role-play of CAMEL Communicative Agents for Mind Exploration of LLM Society.

Tags

CAMEL Communicative Agents for Mind Exploration of LLM Society

CAMEL: Communicative Agents for “Mind” Exploration of Large Language Model Society

Reference: Guohao Li, Hasan Hammoud, Hani Itani, Dmitrii Khizbullin, Bernard Ghanem (2023). NeurIPS 2023 (KAUST). Source file: downloads/camel.pdf. URL

Summary

Introduces role-playing as a scalable cooperation framework for LLM-based agents, along with the CAMEL library for building multi-agent societies. A human specifies only a high-level task idea; a task-specifier LLM expands it into a concrete goal, and two role-playing agents — typically an AI user (e.g. stock trader) and an AI assistant (e.g. Python programmer) — then converse, under carefully engineered inception prompts, until the task is solved. The framework studies failure modes of naive role-playing (role flipping, conversation deviation, instruction/response loops, flake answers) and presents prompt-engineering countermeasures.

The authors collect and release large role-playing dialogue datasets (AI Society, Code, Math, Science) produced by the framework itself, which have since become a standard resource for studying and finetuning cooperative multi-agent LLM behaviour. The paper is a foundational reference for the wave of LLM multi-agent systems that followed.

Key Ideas

Role-playing with inception prompts as a minimal coordination mechanism
Task-specifier agent separates high-level intent from concrete subgoal
Taxonomy of multi-agent LLM failure modes and prompt-level fixes
Self-generated dialogue corpora (AI Society / Code / Math / Science) as a reusable resource
Open-source CAMEL library — influential infrastructure for the agentic LLM ecosystem

Connections

Conceptual Contribution

Claim: Complex cooperative tasks between LLM agents can be driven by role assignment alone: with carefully designed inception prompts, two role-playing LLMs can autonomously decompose and solve tasks that neither could solve in a single prompt, without hand-engineered dialogue control flow.
Mechanism: A task-specifier LLM first turns a vague idea into a concrete goal. Two agents are then instantiated with opposing role prompts (user / assistant). A conversation loop enforces a strict turn-taking schema (“Instruction: … Input: …”; “Solution: …”), with prompt-level guardrails against role flipping, request/response inversion, and conversation termination heuristics. The same engine, instantiated with different role pairs, generates the released dialogue datasets.
Concepts introduced/used: LLM Agents, Roles, inception prompting, role-playing dialogue, Conversation Protocols, Multi-Agent Systems
Stance: engineering / empirical
Relates to: Co-authored by Guohao Li, who is also a co-author of A Scalable Communication Protocol for Networks of LLMs; CAMEL provides the role-based-cooperation baseline that Agora generalises from paired role-play to heterogeneous open networks of negotiating agents. Complements the pipeline-structured approach of MetaGPT and the tool-use foundations of Toolformer. Connects to the negotiation-protocol tradition of KQML as an Agent Communication Language and FIPA-ACL but at the natural-language level.

Tags

AutoGen - Multi-Agent Conversation Framework

AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation

Reference: Wu, Bansal, Zhang, Wu, Li, Zhu, Jiang, Zhang, Zhang, Liu, Awadallah, White, Burger, Wang (2023). Microsoft Research et al. arXiv:2308.08155v2. Source file: 2308.08155v2.pdf. URL

Summary

AutoGen is an open-source Microsoft framework for building LLM applications as conversations among customisable conversable agents. Each agent has a configurable back-end (LLMs, humans, tools, or a combination) and can send, receive, and react to messages. Developers compose applications by (1) defining specialised conversable agents and (2) programming their interaction patterns via natural language prompts and/or code — a paradigm the authors call conversation programming.

The framework supports diverse topologies (two-agent chat, group chat, hierarchical chat, dynamic routing), human-in-the-loop participation, and tool execution via code or function calls. Empirical studies demonstrate AutoGen on math, coding, QA, operations research, online decision-making, and entertainment tasks, showing that multi-agent conversations can exceed single-agent performance while reducing development effort.

Key Ideas

Conversable agents as the unifying abstraction — uniform message interface over LLMs, humans, and tools.
Conversation programming: defining agent capabilities + scripting their interaction patterns as the application-building paradigm.
Flexible conversation topologies: joint chat, hierarchical chat, group chat, dynamic routing.
Human-in-the-loop and tool execution as first-class participants, not special cases.
Empirical validation across six domains showing modular composition yields strong task performance.

Connections

Conceptual Contribution

Claim: Multi-agent LLM applications are best built as conversations between conversable agents whose behaviour is programmed via a fusion of natural-language prompts and code; this abstraction unifies LLM, human, and tool participants under one message-passing model.
Mechanism: Introduces a Python framework with ConversableAgent, AssistantAgent, UserProxyAgent classes; message passing drives LLM inference, human input requests, or tool/code execution; developers declaratively compose agent graphs. Case studies quantify gains over single-agent baselines.
Concepts introduced/used: LLM Agents, Multi-Agent Systems, Tool Use, Agent Communication Languages, Interoperability
Stance: framework / empirical study
Relates to: Cited by Survey Of Agent Interoperability Protocols as prior art for in-framework agent coordination that protocols like Agent-to-Agent Protocol now aim to standardise across frameworks. Its conversation-programming abstraction is a concrete instance of the communication-centric view advocated by Beyond Self-Talk - Communication-Centric Survey Of LLM Multi-Agent Systems.

Tags

Augmented Language Models - A Survey

Augmented Language Models: A Survey

Reference: Mialon, Dessi, Lomeli, Nalmpantis, Pasunuru, Raileanu, Rozière, Schick, Dwivedi-Yu, Celikyilmaz, Grave, LeCun, Scialom (2023). arXiv:2302.07842. Source file: 2302.07842.pdf. URL

Summary

This Meta AI survey introduces the term Augmented Language Models (ALMs): LMs extended with reasoning skills (decomposing a task into subtasks) and tool use (calling external modules like search engines, code interpreters, or other models). The authors argue that while ALMs retain the standard next-token prediction objective, their ability to delegate computation to non-parametric external modules lets them overcome classical LM limitations in interpretability, factuality, and scalability.

The survey organises the landscape around three axes: eliciting reasoning (prompting, recursive prompting, explicit training), using tools and acting (calling models, information retrieval, symbolic computation, embodied actuation), and learning to do so (supervision vs reinforcement learning). It closes with a discussion of limitations and frames ALMs as a natural stepping stone toward autonomous tool-using agents.

Key Ideas

Definition of Augmented Language Models (ALMs) = reasoning + tool use under the standard missing-token objective.
Taxonomy of reasoning techniques: prompting, recursive/iterated prompting, training-time supervision.
Tools surveyed: model-calls, retrieval/RAG, search engines, web navigation, code/symbolic modules, physical actuation.
Learning strategies: hard-coded heuristics, imitation/supervision, and RL from task reward.
ALMs as precursors to agentic systems — the conceptual bridge to later MCP-style tool protocols.

Connections

Conceptual Contribution

Claim: Language models equipped with reasoning decomposition and external tool calls — “augmented” LMs — constitute a distinct research paradigm that can address hallucination, staleness, and interpretability defects of pure parametric LMs without abandoning the language-modelling objective.
Mechanism: Collates and categorises ~200 works into a reasoning/acting/learning triad, showing how each technique (CoT, RAG, toolformer, code execution, embodied action) plugs into the same missing-token framework.
Concepts introduced/used: LLM Agents, Tool Use, Retrieval-Augmented Generation, Interoperability
Stance: survey
Relates to: Foundational conceptual antecedent to Survey Of Agent Interoperability Protocols — the ALM framing underpins why LLMs need a protocol like Model Context Protocol at all; motivates tool-mediated agency that later matures into A2A/ANP-style inter-agent layers.

Tags

Beyond Self-Talk - Communication-Centric Survey Of LLM Multi-Agent Systems

Beyond Self-Talk: A Communication-Centric Survey of LLM-Based Multi-Agent Systems

Reference: Yan, Zhou, Zhang, Zhang, Zhou, Miao, Li, Li, Zhang (2025). arXiv:2502.14321. Source file: 2502.14321.pdf. URL

Summary

This review argues that prior surveys of LLM-based Multi-Agent Systems (LLM-MAS) over-emphasise application domains and agent architectures while neglecting the communication layer that actually enables collaboration. The authors propose a two-level analytical framework separating system-level communication (architecture, goals, and protocols — how agents are organised) from system-internal communication (strategies, paradigms, objects, and content — what messages carry and how they are interpreted).

Drawing on classical communication theory’s source/channel split, they decompose LLM-MAS workflows into speaker/listener, message format, negotiation paradigm, and coordination protocol, then survey representative works under each cell. The review highlights communication efficiency, security vulnerabilities, and benchmark inadequacy as primary open problems.

Key Ideas

Communication as the missing analytical layer in LLM-MAS surveys.
Two-level framework: system-level (architecture, goal, protocol) vs system-internal (strategy, paradigm, object, content) communication.
Adoption of Shannon-style source/channel abstractions to describe LLM agent exchanges.
Brain / Perception / Action model of LLM agents as the atomic communication node.
Open issues: scalability, security of inter-agent channels, multimodal message formats, benchmarking.

Connections

Conceptual Contribution

Claim: The analytical primitive for understanding LLM-MAS is communication, not architecture; a two-level framework (system-level vs system-internal) captures how message protocol choices shape emergent collective behaviour.
Mechanism: Repurposes classical communication-theory distinctions (source/channel, architecture/content) as a taxonomy, then classifies and compares LLM-MAS workflows under each axis, exposing gaps in current designs.
Concepts introduced/used: LLM Agents, Multi-Agent Systems, Agent Communication Languages, Interoperability
Stance: survey
Relates to: Complements Survey Of Agent Interoperability Protocols by analysing communication patterns inside MAS, whereas that survey focuses on inter-agent wire protocols. Shares the communication-first lens with KQML Language And Protocol and FIPA-ACL but reframed for LLM agents.

Tags

Multi-Agent Collaboration Mechanisms - Survey of LLMs

Multi-Agent Collaboration Mechanisms: A Survey of LLMs

Reference: Tran, Dao, Nguyen, Pham, O’Sullivan, Nguyen (2025). arXiv:2501.06322. Source file: 2501.06322.pdf. URL

Summary

An extensive survey of LLM-based Multi-Agent Systems (MASs) focused on collaboration mechanisms. The authors propose an extensible framework characterising collaboration along five dimensions: actors (which agents), types (cooperation / competition / coopetition), structures (peer-to-peer, centralised, distributed), strategies (role-based vs model-based), and coordination protocols. They review methodologies across question answering, planning, debate, and role-play settings, and survey application domains including 5G/6G networks, Industry 5.0, and social simulation.

The survey explicitly positions itself as complementing prior single-agent or architecture-centric reviews by foregrounding collaboration channels — how agents actually talk, negotiate, and align — as the design pivot for scaling toward “artificial collective intelligence.”

Key Ideas

Five-axis taxonomy of MAS collaboration: actors, types, structures, strategies, coordination protocols.
Distinction between cooperative, competitive, and coopetitive channels as interaction primitives.
Peer-to-peer vs centralised vs distributed MAS topologies map onto different coordination protocols.
Role-based vs model-based strategies for dividing labour among specialised LLM agents.
Open problems: scalability, evaluation benchmarks, cultural/social alignment of MAS behaviour.

Connections

Conceptual Contribution

Claim: Understanding LLM-based MAS requires a dedicated taxonomy of collaboration mechanisms, not just architectures or application domains; collaboration can be characterised along actors, types, structures, strategies, and protocols.
Mechanism: Systematically reviews ~130 MAS works, maps each onto the five-dimension framework, then compares coordination protocols (debate, voting, role-play, tool-mediated) and draws lessons about scalability and emergence.
Concepts introduced/used: Multi-Agent Systems, LLM Agents, Agent Communication Languages, Interoperability, Agent Discovery
Stance: survey
Relates to: Cited by Survey Of Agent Interoperability Protocols as prior art motivating its protocol-centric lens; offers a more behavioural counterpart to that paper’s structural comparison of MCP/ACP/A2A/ANP. Converges with Survey Of AI Agent Protocols on the need to treat protocols as ecosystems, not point-to-point specs.

Tags

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

Rubin Causal Model

Potential-outcomes framework (Rubin 1974): each unit has a counterfactual outcome under each treatment level; causal effects are unit-level differences in potential outcomes, identified via Ignorability + Positivity + SUTVA.

In this vault

Potential Outcomes Framework - Rubin

Estimating Causal Effects of Treatments in Randomized and Nonrandomized Studies

Reference: Rubin, D. B. (1974). Estimating Causal Effects of Treatments in Randomized and Nonrandomized Studies. Journal of Educational Psychology 66(5): 688–701. October 1974. APA PsycNet record (DOI 10.1037/h0037350) · ERIC index entry · See also Rubin’s later book with Imbens, Causal Inference for Statistics, Social, and Biomedical Sciences (Cambridge UP 2015) for the canonical textbook statement.

Summary

Rubin’s 1974 paper is the founding statement of the potential-outcomes framework (a.k.a. the Rubin causal model) — the alternative to Pearl’s graphical apparatus that has dominated statistics, econometrics, and biomedical inference. The central move: rather than thinking of causation in terms of mechanisms or structural equations, define a causal effect counterfactually. For each unit i and each treatment level t, posit a potential outcome Yᵢ(t) — the outcome unit i would have exhibited under treatment t. The unit-level causal effect of treatment t versus control c is Yᵢ(t) − Yᵢ(c). The fundamental problem of causal inference is that only one of Yᵢ(t) and Yᵢ(c) is ever observed for any single unit — the other is counterfactual. Causal inference is then statistical inference about the unobserved counterfactual.

The framework’s payoff comes from clarifying the role of randomization. Under random assignment to treatment, observed and counterfactual outcomes are exchangeable: the distribution of Yᵢ(t) in the treated group equals the distribution that would have obtained in the control group had they been treated. The average treatment effect (ATE) E[Y(t) − Y(c)] is then estimable as the simple difference in group means. The framework also clarifies what observational data lets us do: under stated ignorability (a.k.a. conditional exchangeability, no unmeasured confounders) and positivity assumptions, the ATE is identifiable by covariate adjustment — the same calculation Pearl’s backdoor adjustment formula yields, derived from the counterfactual side. Subsequent work (Rosenbaum–Rubin propensity scores 1983, matching, Imbens–Angrist instrumental-variables 1994) builds out the estimation toolbox.

The framework is now the dominant language of causal inference in applied statistics. For CBCL / CIVeX, knowing both languages matters: a CIVeX certificate may be written in either graphical or potential-outcomes notation, and the verifier may need to translate between them. The formal equivalence is established by Pearl–Bareinboim 2009 and Pearl 2010: any non-parametric causal effect expressible in one framework is expressible in the other under translation; the languages differ in ergonomics (graphs make assumptions visually inspectable; potential outcomes make assumptions algebraically inspectable) rather than expressive power. The paper is the place to cite to acknowledge the other half of the causal toolkit.

Key Ideas

Potential outcomes: for each unit i and treatment level t, posit Yᵢ(t) — the outcome unit i would exhibit under t. Both Yᵢ(treated) and Yᵢ(control) are well-defined, but only one is observed for any given unit.
Unit-level causal effect: Yᵢ(t) − Yᵢ(c). Defined for each unit, even though typically unobservable.
Fundamental problem of causal inference: only one potential outcome per unit is observable. Causal inference is statistical inference about the unobserved counterfactual.
SUTVA (Stable Unit-Treatment Value Assumption): implicit in defining Yᵢ(t) as a function of unit and treatment only — (i) no interference between units, and (ii) no multiple versions of treatment. SUTVA violations (peer effects, network spillovers, treatment heterogeneity) require explicit extension.
Ignorability / Conditional Exchangeability: (Y(t), Y(c)) ⫫ T | X — given covariates X, treatment assignment is independent of potential outcomes. The non-graphical statement of “no unmeasured confounders”.
Positivity / Common Support: 0 < P(T = t | X = x) < 1 for all x in the support. Required for ATE identification — must have some chance of either treatment at every covariate level.
Randomization: random assignment of T independent of (Y(t), Y(c)) makes ignorability hold without conditioning. The methodological justification for randomized experiments.
Average Treatment Effect (ATE): E[Y(t) − Y(c)]. The standard target estimand. Identifiable under ignorability + positivity by standardization (covariate adjustment), which yields the same formula as Pearl’s backdoor adjustment.
Successors: propensity score (Rosenbaum–Rubin 1983), matching, instrumental variables (Imbens–Angrist 1994), the Local Average Treatment Effect (LATE), doubly-robust estimation, the entire modern econometric/biostatistical causal-inference toolbox.

Connections

Conceptual Contribution

Claim: Causal effects can be defined and estimated by positing potential outcomes Yᵢ(t) for each unit-treatment pair and treating causal inference as statistical inference about unobserved counterfactuals. Random assignment guarantees identifiability of average effects without further assumptions; observational data require ignorability (no unmeasured confounders) and positivity (common support).
Mechanism: For each unit i and treatment level t, define Yᵢ(t) as the outcome i would exhibit under t. The fundamental problem: only one Yᵢ(t) is observed per unit. Define the unit-level effect Yᵢ(t) − Yᵢ(c) and population estimands (ATE, ATT). Identify the ATE under random assignment without further assumption; under observational data with measured covariates X, identify under ignorability (Y(t), Y(c)) ⫫ T | X and positivity. Estimate by direct standardization, propensity-score adjustment, matching, or instrumental variables when assumptions fail.
Concepts introduced/used: Potential Outcomes, Rubin Causal Model, Counterfactual, SUTVA, Ignorability, Positivity, Average Treatment Effect, Propensity Score (later), Instrumental Variable (later), Fundamental Problem of Causal Inference.
Stance: foundational technical paper.
Relates to: The complementary framework to Pearl 1995 / Causality 2000 — the same causal effects in different notation. Pearl–Bareinboim 2009 and Pearl 2010 establish formal mappings between the two; ignorability + positivity in the Rubin language correspond to the existence of an admissible covariate set in the Pearl backdoor sense. The languages differ in ergonomics: graphs make assumptions visually inspectable; potential outcomes make assumptions algebraically inspectable and integrate naturally with regression-based estimation. The 1974 paper is the seed; the canonical textbook statement is Imbens–Rubin 2015. For CBCL / CIVeX, the framework provides the other half of the causal toolkit: a CIVeX certificate may state its identification claim in either potential-outcomes or graphical language, and the verifier may need to translate. Knowing both is part of the technical literacy required for serious causal-claim verification. Shpitser–Pearl 2006’s completeness on the graphical side has no equally clean counterpart on the potential-outcomes side — the practical computational ground favours graphs.

ID Algorithm

Tian–Pearl complete algorithm for identifying causal effects from observational data on a Semi-Markovian Causal Model: returns an estimand if and only if the effect is identifiable, otherwise reports a hedge.

In this vault

Identification of Joint Interventional Distributions - Shpitser Pearl

Identification of Joint Interventional Distributions in Recursive Semi-Markovian Causal Models

Reference: Shpitser, I. & Pearl, J. (2006). Identification of Joint Interventional Distributions in Recursive Semi-Markovian Causal Models. In Proceedings of the 21st National Conference on Artificial Intelligence (AAAI-06), Boston, July 2006, pp. 1219–1226. URL (AAAI PDF) · Companion: What Counterfactuals Can Be Tested, UAI-07

Summary

Shpitser and Pearl give the complete identification algorithm for non-parametric causal effects in recursive semi-Markovian causal models — the result that finishes the project Pearl 1995 began. The headline: given a DAG with possibly hidden variables, and a target intervention distribution P(Y | do(X = x)), there is a sound and complete algorithm — ID — that either returns a closed-form expression in the observational distribution P(V) or proves that no such expression exists (the effect is unidentifiable). Where Pearl 1995 gave sufficient conditions (backdoor, front-door) leaving a grey zone of “we haven’t found an adjustment, but maybe one exists,” Shpitser–Pearl close the grey zone: the ID algorithm finds an expression if and only if one exists. The do-calculus of Causality (2000) turns out to be exactly the right deductive system — the ID algorithm is essentially a complete proof-search procedure for do-calculus derivations.

The mechanism is technical but compact. The algorithm operates on a semi-Markovian causal DAG (a DAG with hidden / latent variables represented by bidirected edges in the ADMG — acyclic directed mixed graph). It recursively decomposes the target distribution by c-component factorisation — a generalisation of chain-rule decomposition that respects the latent-variable structure — and at each step either reduces to an identified sub-problem or detects a hedge, a particular graphical pattern (the canonical obstruction to identifiability) that proves unidentifiability. The companion paper What Counterfactuals Can Be Tested (UAI-07) extends the framework to counterfactual queries (layer-3 in the Pearl ladder), characterising which counterfactuals are identifiable from interventional data.

For CBCL / CIVeX, the Shpitser–Pearl ID algorithm is the operational substrate. A CIVeX certificate states a target causal query, the assumed DAG, and the ID derivation that identifies the query in terms of observational data. The verifier — running a small implementation of ID — checks the derivation against the algorithm. If the certificate type-checks, the causal claim is provably identifiable under the stated assumptions; if it fails, the certificate is rejected. Completeness means the verifier never needs to ask the prover for a different formulation: if any identification exists, ID finds it. The classical pair with PCC is exact: PCC + ID together give the picture of “ship the causal proof, check the proof” for causal-inference artefacts. Shpitser–Pearl is therefore one of the most direct technical citations the CBCL / CIVeX discussion section needs.

Key Ideas

Recursive semi-Markovian causal model: an acyclic directed graph over observed and hidden variables, equivalently an acyclic directed mixed graph (ADMG) over observed variables with bidirected edges representing shared hidden parents. The standard formal substrate for causal identifiability when some confounders are unmeasured.
Joint interventional distribution: P(Y | do(X = x)) for Y a (possibly multivariate) target and X a (possibly multivariate) intervention set. The paper handles the joint multivariate case rather than just single-cause single-effect.
ID algorithm: a recursive procedure that either returns a closed-form expression for P(Y | do(X = x)) in terms of P(V) (the observational distribution over observed variables) or detects unidentifiability via a hedge obstruction.
Soundness and completeness: the ID algorithm is sound (every expression returned is correct) and complete (if any expression for P(Y | do(X = x)) exists, ID returns one). Together with the soundness/completeness of do-calculus, this fully resolves non-parametric identifiability.
c-component factorisation: the structural decomposition that drives ID. Each c-component is a maximal set of observed variables connected by paths of bidirected edges; the joint distribution factorises along c-components in a way that respects the latent-variable structure.
Hedge as canonical obstruction: a hedge is a particular graphical pattern (a pair of c-forests in a tree-like configuration) whose presence proves unidentifiability. Every unidentifiable case witnesses a hedge.
Completeness of do-calculus: a corollary — Pearl’s three-rule do-calculus is complete for non-parametric identification. The ID algorithm is, in effect, an automated do-calculus prover.
Companion: counterfactual identification: What Counterfactuals Can Be Tested (UAI-07) extends the framework to layer-3 (counterfactual) queries, characterising which counterfactuals can be identified from interventional distributions.

Connections

Conceptual Contribution

Claim: For non-parametric causal identification in recursive semi-Markovian models, there is a sound and complete algorithm: given a target intervention distribution and a DAG with hidden variables, the algorithm either expresses the target in observational quantities or proves unidentifiability via the hedge graphical pattern. As a corollary, Pearl’s do-calculus is complete for identification.
Mechanism: The ID algorithm operates on a semi-Markovian DAG (or equivalently an ADMG over observed variables). At each recursive step, it performs c-component factorisation to decompose the target distribution along the latent-variable-induced equivalence classes; it then either reduces the problem to identified subproblems or recognises a hedge obstruction and outputs unidentifiable. Soundness follows from each step being a do-calculus transformation; completeness follows from hedges being the only obstruction.
Concepts introduced/used: ID Algorithm, c-Component, Hedge (Causal Inference), Semi-Markovian Causal Model, Acyclic Directed Mixed Graph, Identifiability, Completeness of do-Calculus.
Stance: foundational technical paper.
Relates to: The algorithmic completion of Pearl 1995 / Causality 2000: where 1995/2000 gave sufficient graphical conditions and the deductive do-calculus, Shpitser–Pearl 2006 gives the complete decision procedure. The companion What Counterfactuals Can Be Tested (UAI-07) extends to layer-3 queries. The complementary framework is Rubin’s potential outcomes; the algorithmic completeness on the graphical side has no equally clean counterpart on the potential-outcomes side, which is part of why graphical methods have won the practical computational ground. For CBCL / CIVeX, this is the operational substrate: a CIVeX certificate carries a DAG, a target query, and an ID derivation; the verifier runs a small ID implementation to check the derivation. Pairs with PCC in the obvious way: PCC + ID = “ship the causal proof, check the proof” for causal-inference artefacts. The CBCL/CIVeX discussion section’s claim that causal certificates are decidably checkable leans on Shpitser–Pearl completeness; without it, the architecture would have to apologise for occasionally being too weak.

Ladder of Causation

Pearl’s three-rung hierarchy: association (seeing), intervention (doing), and counterfactual (imagining). Each rung is strictly more expressive; observational data alone cannot answer rung-2 or rung-3 questions without additional structural assumptions.

In this vault

Structural Causal Model

Pearl’s framework for causal reasoning: a set of structural equations + a Causal DAG over endogenous and exogenous variables, supporting observational, interventional, and counterfactual queries via the three-rung ladder of causation.

In this vault

Causality - Pearl

Causality: Models, Reasoning, and Inference

Reference: Pearl, J. (2000, 2nd ed. 2009). Causality: Models, Reasoning, and Inference. Cambridge University Press. 384 pp (1st ed.) / 484 pp (2nd ed.). URL (ILLC Amsterdam, 2nd ed. PDF) · Cambridge UP page · Internet Archive

Summary

Causality is the book-length statement of Pearl’s graphical-causal-inference programme — the work that fixes a usable vocabulary for causation in the empirical sciences, replacing decades of philosophical regress with a constructive theory. The book extends the apparatus of Causal Diagrams for Empirical Research (1995) along three axes. (1) From interventional to counterfactual causal queries: the structural causal model (SCM) — a system of structural equations with exogenous error terms — supports queries about what would have happened if particular variables had taken different values, not only about intervention distributions. (2) From backdoor / front-door criteria to do-calculus: a complete deductive system (three rules: insertion/deletion of observations, action/observation exchange, and insertion/deletion of actions) for transforming do-expressions. Together with Shpitser & Pearl 2006’s completeness result, do-calculus is complete for non-parametric identifiability. (3) From identifiability to applied causal inference: chapters on confounding, mediation, instrumental variables, the actual-cause problem, and the foundations of legal-causal reasoning.

The technical core in three layers. Layer 1 (association): ordinary probabilistic conditional P(Y | X). Layer 2 (intervention): post-do distribution P(Y | do(X = x)), derived from the SCM by surgical replacement of X’s equation. Layer 3 (counterfactuals): queries like P(Y_{X=x} | X = x', Y = y') — “given that we observed X = x' and Y = y', what would Y have been if we had set X = x?” — derived by the abduction–action–prediction procedure: update exogenous-error distributions on the evidence, intervene on X, predict Y. Pearl calls this stratification the Ladder of Causation; the book argues that the climb from layer 1 to layer 3 is a matter of added assumptions (structural equations, then exogenous-error distributions), not of finer-grained statistical methodology.

For CBCL and CIVeX, the book is the textbook reference. CIVeX certificates carry a DAG, a stated set of structural assumptions, and a do-calculus derivation establishing identifiability of the target causal query. The host’s verifier checks the derivation against the do-calculus rules. The completeness of do-calculus (Shpitser & Pearl 2006) means that the verifier never has to apologise for being too weak: if the effect is identifiable at all, do-calculus derives it. The book also supplies the vocabulary for stating what CIVeX certificates are claiming: distinctions between association, intervention, and counterfactual; between identifiability and estimability; between confounding, mediation, and selection — all of which are needed to write precise threat models for causal claims in multi-agent settings.

Key Ideas

Structural Causal Model (SCM): a system of structural equations Vᵢ := fᵢ(PAᵢ, Uᵢ) over endogenous variables V with exogenous errors U, plus a distribution over U. The SCM is the formal carrier of all three causal layers.
Ladder of Causation: three layers of causal queries, each requiring strictly more assumptions. Layer 1 (seeing) — P(Y | X). Layer 2 (doing) — P(Y | do(X = x)). Layer 3 (imagining) — counterfactuals P(Y_{X=x} | E) for arbitrary evidence E.
do-calculus: three syntactic transformation rules over do-expressions: (R1) insertion/deletion of observations under d-separation; (R2) action/observation exchange under modified d-separation; (R3) insertion/deletion of actions under absence-of-causal-paths. Combined with probability axioms, the calculus is complete for non-parametric identifiability (Shpitser–Pearl 2006).
Identifiability under unobserved confounders: many effects are identifiable even when key confounders are unmeasured. The do-calculus discovers when, and the Shpitser–Pearl ID algorithm gives a complete procedure.
Counterfactual queries by abduction–action–prediction: (i) Update P(U) on observed evidence (abduction). (ii) Intervene on the SCM (action). (iii) Compute the distribution of the target variable (prediction). The procedure yields counterfactuals from the SCM.
Mediation analysis: natural direct, natural indirect, and total effects decompose causal influence along specific paths. Identification conditions are characterised by the mediation formula and the more general path-specific effects.
Instrumental variables: a classical econometric tool given a clean graphical characterisation — an instrument is a variable affecting X but not Y directly or via unmeasured confounders. The IV estimand is recoverable when the graphical conditions hold.
Actual cause / responsibility: chapter 10 develops a formal theory of actual causation — what actually caused the outcome in this token case? — built on counterfactuals and contingency. Foundational for legal and AI-ethics applications.
Transportability: under what conditions can a causal effect estimated in one population be transferred to another? Bareinboim–Pearl give graphical criteria.

Connections

Conceptual Contribution

Claim: Causal reasoning admits a precise, computable, non-parametric foundation built on structural causal models (SCMs), the do-operator for intervention, and the do-calculus for transforming causal queries. The three-layer Ladder of Causation (association / intervention / counterfactual) stratifies the assumptions required for each kind of causal claim.
Mechanism: Define SCMs as systems of structural equations with exogenous errors. Define interventions surgically (replace X’s equation by X := x). Define counterfactuals via abduction–action–prediction on the SCM. Give the do-calculus (three transformation rules) and show it is sound; later work (Shpitser–Pearl 2006) shows it is also complete for identification. Extend to mediation, instruments, actual causation, transportability across populations.
Concepts introduced/used: Structural Causal Model, Ladder of Causation, do-Calculus, Counterfactual, Mediation Analysis, Instrumental Variable, Actual Cause, Transportability, Identifiability.
Stance: foundational technical monograph / textbook.
Relates to: The book that the paper Causal Diagrams (1995) prefigures and that Shpitser & Pearl 2006 completes algorithmically. The complementary framework is Rubin’s potential outcomes (1974): the same causal effects in counterfactual notation, with explicit formal mappings between the two languages (Pearl–Bareinboim 2009). For CBCL / CIVeX, the book is the textbook reference: CIVeX certificates carry DAGs, structural assumptions, and do-calculus derivations of identifiability; the host’s verifier checks the derivation against the calculus. The PCC pairing is exact (Necula): PCC ships behavioural proofs over machine states; CIVeX ships causal-identification proofs over the DAG; both rely on small, generic verifiers that check rather than re-derive.

Backdoor Criterion

Pearl’s graph-theoretic condition for identifying a sufficient adjustment set in a Causal DAG: block every non-causal path from treatment to outcome while opening no collider. Workhorse of observational causal inference.

In this vault

do-Calculus

Pearl’s three-rule deductive system for transforming expressions involving the do-operator — the formal representation of intervention in causal models. The three rules are: (R1) insertion / deletion of observations under appropriate d-separation in the modified graph; (R2) action / observation exchange when an action behaves like an observation under d-separation; (R3) insertion / deletion of actions when no causal paths exist. Together with the probability axioms, do-calculus is complete for non-parametric identification of interventional distributions (Shpitser–Pearl 2006): every identifiable effect is derivable by the three rules, and every unidentifiable effect is provably so. The do-calculus is essentially the rule-set the ID Algorithm mechanises into an automated decision procedure.

In this vault

Causal Diagrams for Empirical Research - Pearl

Causal Diagrams for Empirical Research

Reference: Pearl, J. (1995). Causal Diagrams for Empirical Research. Biometrika 82(4): 669–688. December 1995. With discussion and rejoinder. URL (UCLA CogSys Lab) · DOI

Summary

Pearl’s Causal Diagrams is the paper in which the modern graphical apparatus of causal inference takes recognisable shape: directed acyclic graphs (DAGs) over observed and latent variables as the carrier of non-parametric causal assumptions, the do-operator as the formal representation of intervention, and the backdoor criterion as the first widely-usable graphical test for whether a causal effect is identifiable from observational data given a set of measured covariates. Where the early structural-equations and path-analysis tradition (Wright 1921, Haavelmo 1943) had given causal interpretations to specific parametric models, and where the do-then-randomise tradition (Rubin 1974) had given a counterfactual semantics to causal effects without graphs, Pearl unifies both: the DAG carries the structural assumptions, the do-operator gives the counterfactual semantics, and a small algebra of graphical operations decides identifiability.

The mechanism is precise. A causal model is a DAG G over variables V together with structural equations or, more generally, a non-parametric structural model. The do-operator do(X = x) represents the intervention that sets X to x regardless of X’s natural causes — graphically, by severing the incoming edges to X in G. A causal effect P(Y | do(X = x)) is identifiable from observational data over V iff it can be written as an expression in the observational distribution P(V). The backdoor criterion gives a sufficient condition: a set Z of measured covariates is admissible for adjustment iff Z blocks every backdoor path from X to Y (every path with an arrow into X) and contains no descendants of X. When Z is admissible, P(Y | do(X = x)) = ∑_z P(Y | X = x, Z = z) P(Z = z) — the backdoor adjustment formula. The paper also introduces the front-door criterion for cases where backdoor adjustment fails but a mediator can be exploited.

For the CBCL / CIVeX programme, Pearl 1995 is the foundation. CIVeX certificates carry a DAG of causal assumptions and a proof that the queried effect is identifiable from the available data under those assumptions; this is exactly what Pearl establishes is expressible and checkable. The paper is also a methodological complement to the PCC architecture in CBCL: where PCC ships behavioural proofs, CIVeX ships causal-identification proofs, and both are checked against a stated specification rather than re-derived. The completion of the graphical identifiability story — characterising exactly which causal effects are identifiable in the presence of unobserved confounders — is Shpitser & Pearl 2006’s complete-ID algorithm; Pearl 1995 is the place the story starts to look like an algorithm rather than a case-by-case analysis.

Key Ideas

Causal DAG as non-parametric structural model: a DAG G over V together with structural equations (or a non-parametric Markov-compatible distribution). The DAG carries the causal assumptions; the distribution is what is observed.
do-operator: do(X = x) represents intervention — setting X to x by external manipulation, severing the natural mechanisms that determine X. Graphically: delete incoming edges to X in G; semantically: replace X’s structural equation with X := x. The post-intervention distribution P(V | do(X = x)) is the central object of causal inference.
Identifiability: a causal query P(Y | do(X = x)) is identifiable from observational data over V iff it can be written as an expression in P(V). Identifiability is a graphical property — it depends only on the DAG, not on the specific distribution.
Backdoor criterion: Z ⊆ V is admissible for adjustment iff (i) no node in Z is a descendant of X in G, and (ii) Z blocks every backdoor path from X to Y (every path with an arrow into X). When Z is admissible, P(Y | do(X = x)) = ∑_z P(Y | X = x, Z = z) P(Z = z).
Front-door criterion: when no admissible Z for backdoor adjustment exists, identification may still be possible via a mediator M on the directed path from X to Y. The front-door formula uses M to identify the effect even in the presence of unobserved confounders.
Markov compatibility / d-separation: G constrains P(V) via conditional-independence statements encoded by d-separation — a purely graphical criterion. The empirical content of a causal DAG is exactly the d-separations it implies.
Bridge to interventions: causal effects can be defined purely structurally (no counterfactual ontology needed) by reference to the post-intervention distribution. Counterfactuals re-enter when finer-grained queries (mediation, attribution) are asked, handled by structural causal models in Pearl’s later work.

Connections

Conceptual Contribution

Claim: Causal effects can be represented graphically (as DAGs over observed and latent variables) and identified from observational data by a calculus of graphical operations. The do-operator gives the formal semantics of intervention; the backdoor and front-door criteria give algorithmic identifiability conditions.
Mechanism: Encode causal assumptions as a DAG G over V. Define interventions via the do-operator, semantically the surgical replacement of X’s structural equation by X := x and graphically the severing of incoming edges. State identifiability as the existence of an expression in P(V) for P(Y | do(X = x)). Give the backdoor criterion as a sufficient graphical condition (block all backdoor paths, no descendants of X) together with the backdoor adjustment formula. Give the front-door criterion for the harder case of unmeasured confounding. The result is a non-parametric, graph-driven, algorithmic theory of causal identification.
Concepts introduced/used: do-Calculus, Causal DAG, Structural Causal Model, Intervention, Backdoor Criterion, Front-door Criterion, d-Separation, Identifiability, Markov Compatibility.
Stance: foundational technical paper.
Relates to: Pearl’s compact statement of the apparatus developed at book length in Causality (2000/2009); the algorithmic completion is Shpitser & Pearl 2006. The complementary tradition is Rubin’s potential-outcomes framework (1974) — the same causal effects in counterfactual notation; later work (Pearl–Bareinboim, Imbens–Rubin) establishes formal mappings between the two. For CBCL and CIVeX, this is the substrate: a CIVeX certificate carries a DAG and a proof of identifiability under stated assumptions, checked by the host rather than re-derived. The pairing with PCC is exact: PCC ships behavioural proofs over machine states; CIVeX ships causal-identification proofs over the DAG. The d-separation / Markov-compatibility connection grounds the bridge to probabilistic graphical models more broadly.

Seven Turrets Of Babel

The Seven Turrets of Babel: A Taxonomy of LangSec Errors and How to Expunge Them

Reference: Momot, Bratus, Hallberg, Patterson (2016). IEEE Cybersecurity Development (SecDev). Source file: 7turretsaspublished.pdf. URL

Summary

The authors catalogue seven recurring classes of input-handling bugs under the LangSec (language-theoretic security) lens: shotgun parsing, non-minimalist input-handling code, differing interpretations of the input language, incomplete protocol specification, overloaded fields in input format, permissive processing of invalid input, and inability to express input languages in the Chomsky hierarchy. Each class is grounded in concrete CVEs (Heartbleed, Android Master Key, Rosetta Flash, OpenSSL CVE-2016-0752).

LangSec’s remedy is to treat input acceptance as a formal language-recognition problem: specify a grammar no more complex than deterministic context-free, build a recognizer that fully validates before any processing, and cleanly separate parsing from application logic. The paper proposes new CWE entries naming each weakness so auditors can precisely describe vulnerable input-handling code.

Key Ideas

LangSec: input should be a well-defined language with a fully-validating recognizer.
Seven anti-patterns: shotgun parsing, non-minimalist code, interpretation drift, incomplete spec, field overloading, permissive invalid input, undecidable grammars.
Chomsky hierarchy as a safety ceiling for input languages.
Hand-rolled parsers vs parser-combinator / generator tooling (e.g., Hammer).
Proposed new CWEs to label LangSec anti-patterns.

Connections

Conceptual Contribution

Claim: Most serious input-handling vulnerabilities reduce to seven recurring anti-patterns, all addressable by treating input acceptance as a formal language-recognition problem bounded by the Chomsky hierarchy.
Mechanism: Catalogues each anti-pattern (shotgun parsing, non-minimalist code, interpretation drift, incomplete spec, field overloading, permissive invalid input, undecidable grammars) against real CVEs (Heartbleed, Android Master Key, Rosetta Flash); prescribes grammar-first validating recognizers and proposes new CWE entries.
Concepts introduced/used: LangSec, Shotgun Parsing, Chomsky Hierarchy, Parser Combinators, Distributed Security, Common Weakness Enumeration
Stance: engineering / critique
Relates to: Shares a language-theoretic security stance with A Language-Based Approach To Prevent DDoS and Security Kernel Lambda Calculus; its grammar-discipline arguments apply directly to the schema/protocol surfaces catalogued in Survey Of Agent Interoperability Protocols and exploited in MalTool Malicious Tool Attacks.

Tags

How Do Committees Invent

How Do Committees Invent?

Reference: Melvin E. Conway (1968). Datamation, April 1968, pp. 28-31. Source file: Conway, Melvin E._ How Do Committees Invent_. In_ Datamation (1968).pdf. URL

Summary

Conway’s classic essay articulates what is now known as Conway’s Law: “organizations which design systems are constrained to produce designs which are copies of the communication structures of these organizations.” He argues that the structure (graph) of any designed system is homomorphic to the structure of the design organization that produced it, because each interface in the system corresponds to a coordination path between subgroups.

Drawing on examples from compiler development, military weapons systems, and public administration, Conway traces how organization charts end up printed onto product architectures. He closes with a warning against premature commitment to an initial design organization, since such commitment freezes choices and leaves systems unable to be decomposed sensibly later — “systems tend to disintegrate” as the organization evolves.

Key Ideas

System structure mirrors the communication structure of its designers (Conway’s Law).
Design organization choices shape the set of alternatives considered.
Homomorphism argument: interfaces between subsystems = coordination between subgroups.
Organizations must stay flexible to avoid freezing a suboptimal design.
Applicability beyond software: any large coordinated design effort.

Connections

Multi-Agent Systems
Agent Communication Languages
Self-Adaptive Systems
Standard Operating Procedures (SOPs)
Protocol Documents
Interaction Protocols
Levels Of Social Orchestration — extends Conway to agent-population architecture
A Scalable Communication Protocol for Networks of LLMs — Agora protocol documents as “language = organisation”
Vibe Coding — the organisation-mirror problem when the “organisation” includes AI agents

Conceptual Contribution

Claim: The structure of a designed system is homomorphic to the communication structure of the organization that designs it (Conway’s Law); therefore design-team topology pre-determines the space of realisable architectures.
Mechanism: An informal homomorphism argument — every subsystem maps to a design subgroup and every interface maps to a negotiation path — illustrated through compiler, weapons system, and public-administration case studies; followed by a disintegration argument (overpopulation + rigid management practice fragment the communication graph, which fragments the product).
Concepts introduced/used: Conway’s Law, System Homomorphism, Communication Structure, Design Organization, Coordination, Interface
Stance: foundational / critique
Relates to: Provides the organisational backdrop for every multi-agent architecture in the vault; pairs naturally with Multiagent Systems Sycara (which treats the agent organisation as a deliberate design variable) and with A Scalable Communication Protocol for Networks of LLMs (whose protocol shape will, by Conway’s Law, shape the societies of LLMs built atop it).

Tags

Algorithmic Information Theory - Grunwald Vitanyi

Algorithmic Information Theory

Reference: Peter D. Grünwald and Paul M.B. Vitányi (2008). arXiv:0809.2754v2 (book chapter, Handbook of Philosophy of Information). Source file: 0809.2754v2 (1).pdf. URL

Summary

A tutorial survey of algorithmic information theory (Kolmogorov complexity) and its relationship to Shannon information theory. The authors explain how the amount of information in an individual object can be measured by the length of the shortest program that produces it, and how this quantity — invariant up to an additive constant — supports a non-probabilistic theory of information.

The chapter covers the invariance theorem, uncomputability, relation to entropy, mutual information, the Kolmogorov structure function (separating meaningful/structural from random information), Minimum Description Length, normalized compression distance, and the philosophical implications for Occam’s razor and inductive inference.

Key Ideas

Kolmogorov complexity K(x) as length of shortest program outputting x
Invariance theorem makes K objective up to an additive constant
Structure function separates meaningful (model) from random content
MDL as a practical approximation of ideal algorithmic inference
Entropy is expected Kolmogorov complexity under computable distributions

Connections

Conceptual Contribution

Claim: The information content of an individual object is objectively measured by the length of the shortest program that prints it — Kolmogorov complexity — and this gives a formal basis for Occam’s razor, randomness, and “meaningful” vs “random” information.
Mechanism: Define K(x) via a universal Turing machine (invariance up to additive constant); extend via prefix codes, the Kolmogorov structure function (separating structural/model part from random/noise part), and the Minimum Description Length principle for inductive inference.
Concepts introduced/used: Kolmogorov Complexity, Minimum Description Length, Kolmogorov Structure Function, Shannon Information, Shannon Entropy, Occam’s Razor, Universal Turing Machine, Invariance Theorem, Normalized Compression Distance, Inductive Inference, Prefix Codes
Stance: formal-mathematical / foundational
Relates to: Provides the information-theoretic backdrop for why compact emergent codes arise in Emergence of Grounded Compositional Language in Multi-Agent Populations and Multi-Agent Cooperation and the Emergence of Natural Language; and for the description-length intuition behind compositional protocol negotiation in A Scalable Communication Protocol for Networks of LLMs. Complements Chomsky’s grammar-based view in Three Models for the Description of Language.

Tags

Hoare Logic

Axiomatic program-verification system based on Hoare triples {P}C{Q}; direct descendant of Floyd’s edge-assertion method.

In this vault

An Axiomatic Basis for Computer Programming - Hoare

An Axiomatic Basis for Computer Programming

Reference: Hoare, C. A. R. (1969). An Axiomatic Basis for Computer Programming. Communications of the ACM 12(10): 576–580, 583. October 1969. URL (MIT-hosted PDF) · ACM DOI

Summary

The founding paper of axiomatic semantics and the source of Hoare logic — the contract-based reasoning method whose direct descendants include Eiffel-style design-by-contract, separation logic, refinement types, F*, Dafny, Lean’s decreasing_by, and every behavioural-spec system that talks about programs in terms of preconditions and postconditions. Hoare proposes that the meaning of a program be given not by operational trace but by a partial-correctness assertion of the form {P} S {Q}: if P holds before executing S, and S terminates, then Q holds after. The axiomatic semantics consists of axiom schemes and inference rules for each programming-language construct: an assignment axiom ({Q[E/x]} x := E {Q}), composition ({P} S₁ {R}, {R} S₂ {Q} ⊢ {P} S₁; S₂ {Q}), conditional, while-loop with loop invariant, and rule of consequence (strengthen P, weaken Q). The system gives programmers a calculus for reasoning about programs symbolically, without enumeration.

Two methodological commitments distinguish the paper. First, Hoare deliberately treats the axioms as defining the programming language: the semantics of := is the assignment axiom, full stop. Implementations that fail to satisfy the axiom are bugs in the implementation, not in the axiom. This is the cornerstone of the abstract specification view of programming-language semantics. Second, Hoare takes partial correctness (correctness given termination) as the unit of reasoning, separating it from termination (which he discusses as a separate problem). This separation pays off massively later: partial correctness is recursively axiomatisable in a way total correctness is not, and the loop-invariant rule becomes the central engine of program verification.

For the verification line in this vault, Hoare 1969 is the root of the tree: every contract-based, behavioural-spec, certificate-bearing technology — Hoare logic itself, Floyd’s inductive assertions (1967, the direct ancestor with which Hoare credits in §1), PCC, EM enforcement, dependent-typed proof assistants — sits downstream. The pair axiomatic semantics + proof-carrying-code is the conceptual spine of how CBCL turns dialect contracts into machine-checkable assertions: a dialect contract is a Hoare-style pre/post over the wire-format trace, and the Lean proof of its well-formedness is the PCC-style certificate.

Key Ideas

Partial-correctness Hoare triple: {P} S {Q} means “if P holds before executing S, and S terminates, then Q holds after.” The fundamental unit of reasoning.
Axiomatic definition of programming-language constructs: each construct is defined by its axiom or rule (assignment, composition, conditional, loop, consequence). The axioms are the semantics; implementations must conform.
Assignment axiom: {Q[E/x]} x := E {Q} — to know Q holds after assigning E to x, ensure Q[E/x] (substitute E for x in Q) holds before. The backward substitution rule is the surprising core of the system.
Composition rule: {P} S₁ {R} and {R} S₂ {Q} together give {P} S₁; S₂ {Q}. The middle assertion R is the bridging condition.
Conditional rule: {P ∧ B} S₁ {Q} and {P ∧ ¬B} S₂ {Q} give {P} if B then S₁ else S₂ {Q}.
While-loop rule (loop invariant): {I ∧ B} S {I} gives {I} while B do S {I ∧ ¬B}. The loop invariant I is the central object of program verification and the place programmer ingenuity is needed.
Rule of consequence: P ⇒ P', {P'} S {Q'}, Q' ⇒ Q together give {P} S {Q}. Lets one strengthen preconditions and weaken postconditions to fit context.
Partial vs total correctness: Hoare separates the two; partial correctness is recursively axiomatisable, total correctness requires a separate variant function / termination argument.
Axioms specify abstract machines: real machine arithmetic differs from the axiomatic integer arithmetic (overflow, finite precision); Hoare flags this explicitly and treats it as a design problem rather than a flaw of the method.

Connections

Conceptual Contribution

Claim: The meaning of a program can be given axiomatically by inference rules over assertions of the form {P} S {Q} (Hoare triples), with each programming-language construct defined by its rule. Program verification reduces to deriving the triple {P} program {Q} in the resulting calculus.
Mechanism: Define partial correctness {P} S {Q} as “if P holds and S terminates then Q holds.” Give axioms / rules for each construct: assignment (backward substitution), composition, conditional, while-loop (with loop invariant), and rule of consequence. Separate termination as a distinct concern handled by a variant function. The resulting calculus is sound, in principle complete for partial correctness over a sufficiently expressive assertion language, and treats programming-language semantics as a specification rather than a description of execution traces.
Concepts introduced/used: Hoare Triple, Loop Invariant, Assignment Axiom, Rule of Consequence, Partial Correctness, Total Correctness, Variant Function, Weakest Precondition (worked out later by Dijkstra).
Stance: foundational technical paper.
Relates to: Roots of contract-based verification; direct ancestor of PCC (the proofs PCC ships are essentially Hoare-style derivations of safety predicates), of verifiable ACL semantics (FP/RE pairs are Hoare-style pre/post over communicative actions), and of smart-contract verification. Builds explicitly on Floyd 1967 (inductive assertions on flowcharts). The unification of Floyd-Hoare logic with proof theory is the Curry–Howard correspondence that motivates dependently typed proof assistants (Coq, Lean, Agda) where Hoare triples become dependent function types. For agent communication, the framework is the formal vocabulary for protocol contracts and dialect specifications: a protocol step is a Hoare triple over the public commitment-state, and a CBCL dialect contract is a Hoare-style specification whose proof of soundness is shipped PCC-style.

Assigning Meanings to Programs

Reference: Robert W. Floyd (1967). Proceedings of Symposia in Applied Mathematics, Vol. 19, pp. 19-32 (AMS). Source file: FloydMeaning.pdf. URL

Summary

Floyd’s foundational paper establishes a rigorous, axiomatic basis for proving properties of programs — correctness, termination, equivalence — by attaching propositions (tags) to the edges of a flowchart. A verification condition for each command type guarantees that if the tag on its entrance edge is true when control arrives, then the tag on its exit edge is true when control leaves. Induction over execution then proves global properties like “if initial values satisfy R1, final values satisfy R2”.

The paper defines completeness and consistency of a semantic definition, gives general axioms (axioms 1-4 and corollaries), and derives verification conditions for assignment, conditional branch, join, start, and halt in a simple flowchart language, then extends the approach to fragments of ALGOL. It is a foundational work in axiomatic semantics, directly inspiring Hoare logic.

Key Ideas

Interpretation = mapping from flowchart edges to propositions.
Verification condition per command type enforces local soundness.
Global correctness by induction over execution steps.
Semantic definition should be complete and consistent.
Termination proofs by showing a well-founded quantity strictly decreases.

Connections

Language Workbenches
Agent-Oriented Programming
Verifiable Semantics
Code as Data
Intent Formalization - A Grand Challenge for Reliable Coding — Floyd/Hoare specs as the LLM-era correctness oracle
Making Smart Contracts Smarter — semantic-gap diagnostics in a blockchain setting
Hoare Logic

Conceptual Contribution

Claim: A programming language’s semantics can be defined independently of any implementation by attaching propositions to flowchart edges and constructing per-command verification conditions; global program properties then follow by induction.
Mechanism: Flowchart interpretation as a map from edges to propositions; four general axioms governing verification conditions; derivation of V_c for assignment, branch, join, start, halt; extension to an ALGOL subset (conditional, goto, for, compound, declarations); termination via well-founded decreasing quantities.
Concepts introduced/used: Axiomatic Semantics, Verification Condition, Strongest Verifiable Consequent, Consistency and Completeness, Inductive Assertions, Termination Proof
Stance: foundational / formal-semantic
Relates to: Direct ancestor of Hoare logic and of every verifiable-semantics move in the vault, including Verifiable Semantics for ACLs which transports Floyd/Hoare-style program semantics into the ACL-conformance question. Foundational for Foundations of Logic Programming - Lloyd and reasoning tools in A Modular Approach to Metatheoretic Reasoning for Extensible Languages.

Tags

Foundations Of Illocutionary Logic

Foundations of Illocutionary Logic

Reference: Searle & Vanderveken (1985). Cambridge University Press. Source file: 5F9BF68C-E1C8-11EE-931A-C444DB61CCB4.pdf. URL

Summary

Searle and Vanderveken construct a formalized logic of speech acts, filling the gap between philosophy of language and formal logic. The book recursively defines the space of illocutionary forces from five primitives (assertive, commissive, directive, declarative, expressive) via seven components of illocutionary force (illocutionary point, mode of achievement, propositional-content conditions, preparatory conditions, sincerity conditions, degree of strength, direction of fit).

It develops axiomatic propositional illocutionary logic, laws of illocutionary entailment, commitment, negation, conjunction, and conditionalization, and closes with a semantic analysis of over a hundred English performative verbs. The work is foundational for agent communication languages because it gives a rigorous semantics to the performatives (inform, request, promise, declare, etc.) later adopted by KQML and FIPA-ACL.

Key Ideas

Five illocutionary points: assertive, commissive, directive, declarative, expressive.
Seven components of illocutionary force.
Direction of fit: word-to-world vs world-to-word.
Formal calculus of success conditions and illocutionary entailment.
Semantic definitions of English performative verbs.

Connections

Conceptual Contribution

Claim: The space of possible speech acts is generated recursively from five illocutionary points and seven components of illocutionary force, and admits a genuine formal logic of success and entailment.
Mechanism: Axiomatic propositional illocutionary logic: laws of illocutionary entailment, commitment, negation, conjunction, and conditionalisation; closes with semantic definitions of over a hundred English performative verbs.
Concepts introduced/used: Speech Act Theory, Performatives, Illocutionary Force, Direction of Fit, Sincerity Conditions, Preparatory Conditions, Commitment-based Semantics, Mental State, Mentalistic Semantics
Stance: foundational / formal-semantic
Relates to: Supplies the philosophical semantics imported by KQML Language And Protocol and FIPA-ACL, and re-examined publicly in Agent Communication And Institutional Reality and A Common Ontology Of ACLs.

Tags

Foundations of Logic Programming - Lloyd

Foundations of Logic Programming (Chapter 1: Preliminaries)

Reference: J. W. Lloyd (1987). Springer-Verlag, Second Extended Edition. Source file: 2022-08-18 13-38-01-Lloyd.pdf. URL

Summary

The opening chapter of Lloyd’s canonical textbook on the mathematical foundations of logic programming. It introduces first-order theories, syntax (alphabets, terms, well-formed formulas, clauses, Horn clauses), interpretations and models, and Herbrand semantics as the preferred route for reasoning about logical consequence of a program.

Lloyd motivates logic programming as Kowalski’s insight that “algorithm = logic + control”: a definite program is a set of Horn clauses (the logic), and the inference strategy (SLD-resolution, search order) is the control. He distinguishes “system” languages (committed-choice, concurrent) from “application” languages (PROLOG-style), and sets up the semantic machinery — Herbrand interpretations, models, logical consequence, unsatisfiability — needed for the rest of the book.

Key Ideas

Algorithm = Logic + Control (Kowalski’s principle)
Horn clauses as the executable fragment of first-order logic
Herbrand universe and base; Herbrand interpretations suffice for clause sets
Definite programs vs normal programs (negation)
SLD-resolution as refutation procedure (developed in later chapters)

Connections

Conceptual Contribution

Claim: Logic — specifically first-order Horn-clause logic with SLD-resolution — can serve as a programming language, where a program is a set of definite clauses, a computation is resolution refutation, and the declarative semantics (Herbrand models, least fixpoint) coincides with the procedural semantics.
Mechanism: Rigorously build up first-order theories, interpretations, Herbrand interpretations/bases, unification, and the T_P fixpoint operator; prove soundness and completeness of SLD-resolution; develop negation-as-failure, the Closed World Assumption, and semantics of normal programs; treat Prolog as the canonical realisation of the Kowalski slogan “algorithm = logic + control”.
Concepts introduced/used: Logic Programming, Horn Clauses, SLD Resolution, Herbrand Universe, Unification, Negation as Failure, Fixpoint Semantics, Prolog, Closed World Assumption, First-Order Logic, Algorithm = Logic + Control
Stance: formal / foundational textbook
Relates to: Theoretical substrate for Agent-Oriented Programming, ACRE Agent Conversation Reasoning Engine, and Ensuring Trustworthy and Ethical Behaviour in Intelligent Logical Agents (all of which assume BDI agents implemented in logic-programming languages). The mentalistic-semantics side of ACLs (KQML as an Agent Communication Language, FIPA-ACL) presupposes Lloyd-style logical machinery.

Tags

PBFT

Castro & Liskov’s (1999) Practical Byzantine Fault Tolerance protocol — 3f+1 replicas tolerating up to f Byzantine failures via a three-phase primary-backup protocol (pre-prepare / prepare / commit) plus view-change recovery. The first BFT protocol fast enough for production deployment; demonstrated on Byzantine NFS within 3% of unreplicated performance. Direct ancestor of Tendermint, HotStuff, Diem/Aptos consensus.

In this vault

Multiplexing (von Neumann)

(page does not exist)

Triple Modular Redundancy

(page does not exist)

Fault Tolerance

The capacity of a system to continue correct operation despite failures of components. Von Neumann’s 1952 Caltech lectures gave the founding formal treatment, proving that arbitrarily reliable computation is achievable from components with per-operation error probability ε, provided ε < 1/6 and sufficient redundancy (triplication-and-majority-vote, or, far more efficiently, bundle multiplexing with restoring organs).

In this vault

Probabilistic Logics and the Synthesis of Reliable Organisms from Unreliable Components

Reference: von Neumann, J. (1956). Probabilistic Logics and the Synthesis of Reliable Organisms from Unreliable Components. In C. E. Shannon & J. McCarthy (eds.), Automata Studies, Annals of Mathematics Studies No. 34, pp. 43–98. Princeton University Press. Lectures delivered at the California Institute of Technology, January 4–15, 1952; notes by R. S. Pierce. Reprinted in John von Neumann, Collected Works, vol. 5, Pergamon, 1963, pp. 329–378. IAS PDF (1952 Caltech version) · Caltech CS191 scan of 1956 publication

Summary

Von Neumann’s 1952 Caltech lectures recast logic as a theory of physical automata in which error is not an extrinsic accident but an essential parameter of the system — its importance, he insists, “fully comparable to that of the intended and correct logical structure.” After a schematic axiomatisation of automata as black-box networks of basic organs with time-delay δ and threshold function φ(x) — the McCulloch–Pitts neuron, the Sheffer stroke, and the majority organ are all proved universal — von Neumann asks the central question: if each basic organ malfunctions independently with probability ε, can networks of such organs nevertheless compute reliably? He proves yes, in two stages of escalating sophistication.

The single-line construction (Section 8) replaces every organ in a target network P by a triplicate cluster (O¹, O², O³) whose outputs feed a majority organ; the recursion is carried by induction on the longest serial chain μ(P). The error of a triplicated stage obeys the cubic recurrence η* = ε + (1−2ε)(3η² − 2η³), whose fixed-point analysis reveals a sharp phase transition: for ε < 1/6 the iteration has a stable low-error fixed point η₀ ≈ ε + 3ε² + …, while for ε ≥ 1/6 every error level degenerates toward η = ½ (“total irrelevance”). Numerical evaluation forces ε < 0.0073 in the rigorous version and inflates the network by a factor of 3^μ(P) — exponential in serial depth, hence “impractical.”

The multiplexed construction (Sections 9–11) — the paper’s enduring contribution — replaces each line of the network by a bundle of N lines, encoding a logical “1” as stimulation of ≥ (1−Δ)N lines and “0” as stimulation of ≤ ΔN lines. The system needs two organ types: an executive organ that performs the logical operation line-wise, and a restoring organ that pushes the bundle’s stimulation fraction α toward 0 or 1. For majority organs the restoring map is α* = 3α² − 2α³ (the same sigmoid as the single-line case, but now operating on bundle statistics); for the Sheffer stroke, iterating α⁺ = 1 − α² twice gives α⁺⁺ = 2α² − α⁴ with stable fixed points at 0 and 1 and an unstable fixed point at α₀ = (−1 + √5)/2 ≈ 0.618. A “randomising” permutation U between layers maintains statistical independence so the binomial / normal approximation remains valid. Section 10’s statistical analysis yields ζ ≈ (1 − ξη) + √(ξ(1−ξ)η(1−η)/N) · δ for the response-set size, and with errors ζ’ = ζ + 2ε(½ − ζ) + √(ε(1−ε)/N) · δ’ — so as N → ∞ the deviation collapses Gaussian-fashion. With ε ≈ 0.005 and N ≈ 1000 lines, the per-output failure probability drops to ~10⁻⁸: arbitrary reliability from arbitrarily unreliable components, at logarithmic-in-1/η₁ overhead instead of exponential.

The closing sections speculate on analog implementations via density modulation by fatigue and a “possible neurological interpretation” in which neural pools serve as restoring organs that maintain accuracy across deep computational structures — von Neumann’s gesture toward what would become the cybernetics / connectionism research programme. The paper closes with a self-critical acknowledgement that the present treatment is “unsatisfactory and ad hoc” and that a proper theory of error must be thermodynamical, of the kind Szilard and Shannon had begun for information — explicitly siting itself as scaffolding rather than capstone.

Key Ideas

Error as a first-class design parameter: the engineering of reliable automata requires treating component-malfunction probability ε as comparable in importance to the logical specification itself — not as an externality.
Universality of basic organs: the McCulloch–Pitts neuron with threshold φ(x), the Sheffer stroke, and the majority organ are each individually sufficient to synthesise any automaton; reliability arguments can therefore be conducted in whichever basis is most convenient.
Triple-modular redundancy with majority voting (Section 8): replacing each organ by three copies plus a majority voter, the error recurrence η → ε + (1−2ε)(3η² − 2η³) has a stable low-error fixed point iff ε < 1/6 — the first rigorous analysis of what later generations called TMR.
Critical threshold ε < 1/6 ≈ 0.167: above this, no construction in this basis can drive error below ½ asymptotically — a sharp phase boundary between recoverable and irrecoverable component-fault regimes.
Multiplexing — bundles of N lines per logical wire: replacing each line by N parallel lines and encoding signals as bundle stimulation fractions converts the discrete fault-tolerance problem into a continuous statistical one amenable to the central-limit theorem.
Restoring organ as discrete-time dynamical system: the bundle-stimulation map α → α* = 3α² − 2α³ (majority) or α → 1 − α² (Sheffer) is a sigmoid with stable fixed points at 0 and 1 and an unstable interior fixed point — iteration sharpens the bundle toward the correct logical value.
Randomising permutation U: to preserve statistical independence of bundle lines across layers — required for the binomial/normal approximation — von Neumann inserts a “sufficiently complicated” permutation between executive and restoring stages, foreshadowing later work on interleaving in coding theory.
Bundle response-set size distribution: ζ ≈ (1 − ξη) + √(ξ(1−ξ)η(1−η)/N) · δ, with δ standard normal — the central-limit-theorem core that justifies why “large enough N” gives arbitrary reliability.
Error propagation under faulty Sheffer organs: ζ’ = ζ + 2ε(½ − ζ) + √(ε(1−ε)/N) · δ’ — explicit decomposition into deterministic drift toward ½ and stochastic noise of order 1/√N, the canonical form of every subsequent reliability calculation.
Logarithmic overhead: in multiplexing, the bundle size N required to achieve target error η scales as O(log(1/η)/ε²) — exponentially better than the single-line construction’s 3^μ(P) blow-up, and the conceptual ancestor of modern coding-theoretic gap arguments.
Analog density modulation: Section 12’s speculation that biological computation may achieve reliability via continuous density-modulated firing-rate codes with fatigue-driven self-stabilisation — an explicit conjecture about the architecture of nervous systems.
Neurological speculation: “neural pools” function as restoring organs maintaining accuracy where logical depth is sufficient to require it — a foundational metaphor for ensemble / population coding in computational neuroscience.

Connections

A Mathematical Theory of Communication — Shannon’s noisy-channel coding theorem (1948) is the direct dual: where Shannon proves arbitrary reliability in transmission below capacity, von Neumann proves arbitrary reliability in computation below the 1/6 component-error threshold; both are non-constructive existence proofs powered by probabilistic / random-coding arguments
Theory of Self-Reproducing Automata — von Neumann’s own later (posthumously edited) elaboration, which generalises from reliability-from-unreliability to the complication threshold enabling self-reproduction and evolvability
Can Programming Be Liberated from the von Neumann Style — Backus’s critique of the programming model von Neumann left behind, complementing this paper’s focus on the physical substrate
Three Models for the Description of Language — Chomsky 1956 in the same Automata Studies tradition; together they bracket the discrete / probabilistic theory of computation in the 1950s
Practical Byzantine Fault Tolerance — direct lineal descendant: PBFT’s 3f+1 quorum is the distributed-message-passing analogue of triple-modular majority voting, with the same combinatorial structure
Impossibility of Distributed Consensus with One Faulty Process — FLP 1985 establishes the analogous impossibility boundary for asynchronous message-passing systems, complementing von Neumann’s possibility result for synchronous logic
Brewers Conjecture and the Feasibility of Consistent Available Partition-Tolerant Web Services — CAP and von Neumann’s analysis both quantify what fault tolerance costs in a particular system model
HotStuff — modern BFT consensus inheriting the majority-voting / quorum-certificate architecture
In Search of an Understandable Consensus Algorithm — Raft’s majority-vote leader election operationalises the same primitive at the protocol layer
Programming Erlang Second Edition — “let it crash” + supervision tree is the von Neumann strategy applied to processes: assume components fail, restore from above
Fault Tolerance — concept hub; this paper is the canonical origin
Redundancy — concept hub; this paper is the canonical origin
Majority Vote — concept hub; the 3-out-of-1 majority organ here is the primitive
Byzantine Fault Tolerance — generalisation to arbitrary-fault adversarial models
Replicated State Machine — modern distributed-systems pattern with the same redundancy structure
Natural vs Artificial Automata
Self-Reproducing Automata
Complication Threshold
Error Halting — what von Neumann’s architecture explicitly defeats
Channel Capacity — the Shannon-information counterpart to von Neumann’s reliability threshold ε = 1/6
Architectural Patterns for Dependable Software Systems - SOL — direct modern engineering inheritance
Are Multiagent Systems Resilient to Communication Failures — restates the question for LLM-mediated multi-agent systems
McCulloch-Pitts Neuron — the basic organ assumed in the construction
Sheffer Stroke — the alternative universal basic organ analysed in Sections 9.4 and 10
Triple Modular Redundancy — the engineering pattern this paper inaugurates
Restoring Organ — von Neumann’s term for the sigmoid map that pushes bundle stimulation to {0, 1}
Multiplexing (von Neumann) — the bundle-of-lines construction central to Sections 9–11
Concurrent Constraint Programming — different lineage but shares the multiplexing-style “communication via shared stimulation” intuition
End-to-End Arguments in System Design — Saltzer / Reed / Clark also argue reliability is best handled at semantic layers, but disagree on where: von Neumann argues at every layer simultaneously, end-to-end argues at the highest

Conceptual Contribution

Theory of Self-Reproducing Automata

Theory of Self-Reproducing Automata (Fourth Lecture: The Role of High and of Extremely High Complication)

Reference: von Neumann, J. (edited and completed by Arthur W. Burks) (1966). University of Illinois Press. Source file: VonNeumann.pdf. URL

Summary

This excerpt is the Fourth Lecture of von Neumann’s posthumously edited Theory of Self-Reproducing Automata. Von Neumann compares natural automata (nervous systems) with artificial computing machines across size, speed, energy dissipation per elementary act of information, and error characteristics. He observes that although vacuum tubes are vastly larger and less energy-efficient than neurons, both are far above the thermodynamic minimum — suggesting physics does not fully explain the size gap; reliability likely does.

The core argument concerns complication: below a threshold, a system cannot perform certain tasks at all; above it, qualitatively new behaviors (including self-reproduction and evolution) become possible. Natural automata tolerate errors locally rather than halting on any single fault, an architectural stance he contrasts with the “single-error” fragility of contemporary computers. The discussion foreshadows modern views on redundancy, fault tolerance, and emergent capabilities with scale.

Key Ideas

Complication threshold enables qualitatively new behavior.
Natural automata survive local errors; artificial automata halt.
Analog-digital mixture characterizes biological computation.
Size and reliability trade-offs shape architecture.
Precursor to self-reproducing and evolvable systems theory.

Connections

Self-Adaptive Systems
Multi-Agent Systems
Edge Intelligence
Large Population Models
ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems — modern self-replicating agent, direct lineal descendant
Myconet Fungi Inspired Superpeer Overlay — biological self-organisation
Computational Boundary of a Self — selfhood extended to scale-free cognition
Programming Erlang Second Edition — engineered local-error-tolerance

Conceptual Contribution

Claim: There exists a threshold of “complication” below which automata can only degrade and above which qualitatively new capacities (self-reproduction, evolvable organisation) become possible; biological automata survive precisely because their architecture tolerates local error rather than halting on any single fault.
Mechanism: Von Neumann juxtaposes nervous systems and vacuum-tube computers along size, energy-per-information-act, speed, and error characteristics, noting both far exceed thermodynamic minima so the gap must be architectural. He then argues that digital-analog hybrids with distributed redundancy exhibit error-tolerant behaviour that Turing-style halting-on-first-error machines cannot match, and frames this as a prerequisite for crossing the complication threshold that enables open-ended evolution.
Concepts introduced/used: Complication Threshold, Self-Reproducing Automata, Fault Tolerance, Redundancy, Digital-Analog Hybrid, Error Halting, Natural vs Artificial Automata
Stance: foundational
Relates to: A philosophical wellspring for the “let it crash” supervision of Programming Erlang Second Edition, the fault-tolerance patterns of Architectural Patterns for Dependable Software Systems - SOL, the robustness concerns of Are Multiagent Systems Resilient to Communication Failures, and the emergent-complexity framing behind Computational Boundary of a Self.

Tags

IPFS Content-Addressed Versioned P2P File System

IPFS - Content Addressed, Versioned, P2P File System

Reference: Juan Benet (2014). arXiv:1407.3561 (DRAFT 3). Source file: downloads/ipfs_benet.pdf. URL

Summary

Original whitepaper introducing the InterPlanetary File System (IPFS), a peer-to-peer hypermedia protocol that synthesises ideas from Git (Merkle-DAG object model), BitTorrent (incentivised block exchange via BitSwap), DHTs (Kademlia-based routing), and self-certifying file systems (SFS) into a single content-addressed distributed file system. Objects are referenced by the cryptographic hash of their contents, giving intrinsic integrity, deduplication, and location independence.

The design stack layers an identity/peer-routing layer (S/Kademlia DHT), a block exchange layer (BitSwap with tit-for-tat credit), an object graph layer (Merkle-DAG with links), a naming layer (IPNS for mutable pointers signed by keys), and application-level filesystem semantics. The paper positions IPFS as the substrate for a “permanent web” where content survives independent of any particular host.

Key Ideas

Content addressing: name = hash(content) -> intrinsic integrity, dedup, cacheability
Merkle-DAG as universal object model spanning files, directories, commits
BitSwap: BitTorrent-like block trading generalised beyond single swarms
Kademlia DHT for peer and content routing
IPNS: mutable pointer namespace via signed records keyed to public keys
Self-certifying paths and location-independent fetching

Connections

Conceptual Contribution

Claim: A single peer-to-peer protocol layered over Merkle-DAG content addressing can unify the roles played today by HTTP, Git, BitTorrent, and CDNs, yielding a permanent, decentralised, versioned web.
Mechanism: Five-layer stack — S/Kademlia DHT for identity/routing, BitSwap for incentive-compatible block exchange, Merkle-DAG for the object graph, IPNS for mutable naming via signed records, and filesystem-level conventions above that. All objects are referenced by their SHA-2 multihash, so any peer can serve any object and clients can verify it independently.
Concepts introduced/used: Content-addressed Storage, Merkle-DAG, Gossip Protocols, BitSwap, IPNS, Self-certifying paths, Peer Sampling Service, Hypermedia
Stance: engineering / systems
Relates to: Directly underpins the distribution story for Protocol Documents in A Scalable Communication Protocol for Networks of LLMs — Agora PDs are hash-identified and can be served over any content-addressed store, of which IPFS is the canonical example. Shares the decentralised-naming motivation with Decentralized Identifiers and the self-organising-overlay motivation with Myconet Fungi Inspired Superpeer Overlay.

Tags

The Synthesis of Digital Machines with Provable Epistemic Properties

Reference: Rosenschein, S.J. & Kaelbling, L.P. (1986). Theoretical Aspects of Reasoning about Knowledge: Proceedings of the 1986 Conference (J.Y. Halpern, ed.), Morgan Kaufmann, pp. 83–98. Source file: rosenschein-kaelbling-synthesis-digital-machines.pdf. URL

Summary

Rosenschein and Kaelbling introduce the situated-automata approach to knowledge: rather than treating K(x, phi) as “machine x stores a syntactic representation of phi in its knowledge base”, they define it in terms of a correlation between the state of the machine and the state of its environment. A machine “knows” phi iff phi holds in every environment-state consistent with the machine’s internal state. Under this definition the S5 axioms of epistemic logic fall out as theorems about well-designed embedded systems — without any symbolic storage of formulas.

The paper extends earlier situated-automata work to compositional hardware: synchronous digital machines are analysed by treating their gates and delay elements as agents in a multi-agent system and reasoning about information flow among them. The authors introduce Rex, a language for recursively computing machine descriptions that lets designers build machines with provable epistemic properties from the gate level up. This is the technical foundation for “knowledge as situatedness” that underpins reactive agent architectures.

Key Ideas

Situated-automata semantics: knowledge = correlation between machine state and environment state, not syntactic storage.
S5 axioms (truth, consequential closure, positive and negative introspection) provable for embedded systems under this definition.
Compositional reasoning: gates and delays modelled as agents; knowledge of the whole follows from information flow among components.
Rex: a hierarchical specification language that compiles to digital machines with guaranteed epistemic properties.
Provides a bridge between epistemic logic, control theory, and reactive robotics.

Connections

Conceptual Contribution

Claim: Knowledge in an embedded agent can be defined by state-environment correlation, so epistemic properties can be compiled into hardware rather than reasoned about at runtime.
Mechanism: Possible-worlds semantics where a machine’s internal state partitions environment states; Rex language synthesises circuits whose state partitions provably realise specified knowledge predicates.
Concepts introduced/used: Situated Automata, Correlational Knowledge, Rex Language, Epistemic S5, Embedded Agent.
Stance: foundational/formal; engineering-oriented counterpoint to symbolic AI.
Relates to: Shoham’s Agent-Oriented Programming cites this work as a key alternative route to agenthood: where AOP implements mental state as explicit data structures interpreted at runtime, Rosenschein & Kaelbling show mental state can be compiled away while preserving the same logical semantics. Shoham’s discussion of “natural vs artificial automata” and of Reactive vs Deliberative Agents directly engages with this programme.

Tags

Deals Among Rational Agents

Reference: Rosenschein, J.S. & Genesereth, M.R. (1985). Proceedings IJCAI-85, Los Angeles, CA, pp. 91–99. Source file: rosenschein-genesereth-deals-among-rational-agents.pdf. URL

Summary

Rosenschein and Genesereth present a game-theoretic framework for interactions between intelligent agents with potentially disparate goals. They drop the “benevolent agent” assumption that pervaded early DAI and ask instead: what can purely rational, self-interested agents achieve through communication? The answer is given via payoff matrices, rational offer groups, and binding deals — coalitions of joint moves that no rational agent should unilaterally reject.

They prove that communication, modelled as exchanging offer groups, lets rational agents coordinate on jointly optimal outcomes that are unreachable without communication. The results are illustrated on Prisoner’s Dilemma, multiple-best-plan, and similar bargaining games, showing that binding promises transform defection-prone situations into cooperation. The paper is an early formal bridge between game theory, distributed AI, and agent communication.

Key Ideas

Rejects the benevolent-agent assumption; models agents as utility-maximisers with private goals.
Rational move = a move no agent should ever be persuaded to abandon given common knowledge of rationality.
Offer group = set of joint moves an agent is willing to commit to; deal = intersection of accepted offer groups.
Theorems: existence of non-null rational offer groups; lower bounds on guaranteed payoffs; a Group Rationality Theorem showing communication can dominate no-communication outcomes.
Shows rational cooperation in the Prisoner’s Dilemma once binding deals are available.

Connections

Conceptual Contribution

Claim: Communication among rational, non-benevolent agents can be given a precise game-theoretic semantics in which binding offers transform achievable payoff sets.
Mechanism: Payoff matrices + rationality assumptions (minimal/separate/unique move rationality) + rational offer groups whose intersections define enforceable deals.
Concepts introduced/used: Rational Offer Groups, Binding Deal, Benevolent Agent Assumption, Individual Rationality, Group Rationality.
Stance: foundational/formal (game-theoretic).
Relates to: Shoham’s Agent-Oriented Programming cites this work as one of the key precursors for modelling agent societies without assuming shared goals; AGENT-0’s “commit” primitive is the programming-language analogue of the binding deals formalised here. The paper also foreshadows Negotiation protocols, auction-based coordination, and modern Mechanism Design for MAS.

Tags

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.

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.

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.

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

An Application of a Method for Analysis of Cyclic Programs

Reference: Nissim Francez (1978). IEEE Transactions on Software Engineering SE-4(5): 371-378. URL (DOI: 10.1109/TSE.1978.233857). No open-access PDF located — IEEE paywall, no author preprint on Francez’s Technion page. Cited in McCarthy’s Elephant 2000 - A Programming Language Based on Speech Acts.

Summary

The applied companion to A Proof Method for Cyclic Programs. Francez uses the Francez-Pnueli cyclic-program proof method to prove Dijkstra’s “on-the-fly” garbage collector correct — a paradigmatically hard concurrent, cyclic program in which a mutator and a collector cooperate to manage a shared heap. The paper also compares the Francez-Pnueli approach with an alternative proof of the same algorithm by David Gries using Owicki’s method, discussing what each approach reveals about the algorithm’s invariants and interference structure.

McCarthy cites this paper in Elephant 2000 as concrete evidence that the cyclic-program proof methodology scales to a real concurrent reactive system, supporting his claim that Elephant’s non-terminating speech-act programs admit tractable verification.

Key Ideas

Case study: Dijkstra’s on-the-fly concurrent garbage collector, proved correct in the Francez-Pnueli framework.
Concurrent cyclic behaviour: mutator/collector cooperation analysed via eventual-behaviour invariants.
Comparison with Owicki/Gries: contrasts the Francez-Pnueli cyclic-programs method with Gries’s proof of the same algorithm using the Owicki interference-freedom approach.
Methodological lessons: shows which invariants each proof style makes natural and which it leaves implicit.

Connections

Elephant 2000 - A Programming Language Based on Speech Acts — McCarthy cites this alongside the Francez-Pnueli method paper
A Proof Method for Cyclic Programs — the method applied here
Program Verification
Formal Verification
Hoare Logic
Assigning Meanings to Programs
Verification Condition

Conceptual Contribution

Claim: The Francez-Pnueli cyclic-programs proof method is tractable and perspicuous on a paradigmatically hard concurrent cyclic program — Dijkstra’s on-the-fly garbage collector — and yields a qualitatively different (and in places more natural) account than the Owicki/Gries interference-freedom proof of the same algorithm.
Mechanism: Construct eventual-behaviour invariants describing the mutator/collector cooperation; discharge safety (no live cell is collected) and liveness (garbage is eventually reclaimed) via the cyclic-programs proof rules; juxtapose with Gries’s Owicki-style proof to characterise the methodological difference.
Concepts introduced/used: Program Verification, Formal Verification, Hoare Logic, Verification Condition
Stance: case-study / methodological
Relates to: Pairs with A Proof Method for Cyclic Programs as the empirical leg of the Francez-Pnueli programme on reactive-system verification. McCarthy uses the pair in Elephant 2000 - A Programming Language Based on Speech Acts to argue that the non-terminating, history-referring programs he proposes for speech-act I/O are within reach of contemporary verification techniques — i.e. the “program as logical sentence” stance need not pay a verifiability tax.

Tags

A Proof Method for Cyclic Programs

Reference: Nissim Francez & Amir Pnueli (1978). Acta Informatica 9: 133-157. URL (DOI: 10.1007/BF00289074). No open-access PDF located — Springer paywall, no author preprint on Francez’s Technion page, no Weizmann tech-report copy surfaced. Cited in McCarthy’s Elephant 2000 - A Programming Language Based on Speech Acts.

Summary

Francez and Pnueli propose a proof method for cyclic programs — programs (sequential or concurrent) that are not meant to terminate but to sustain an ongoing, repetitive behaviour: operating systems, reactive processes, garbage collectors. The traditional input-output Hoare-style correctness notion is inapplicable to such programs because there is no terminating output. The paper replaces input-output correctness with a notion of eventual behaviour: properties that must hold infinitely often, eventually, or persistently across the program’s execution, and develops a proof methodology (a precursor of what would become temporal-logic program verification) for discharging these properties.

The paper is an important early step between Floyd-Hoare partial-correctness verification and Pnueli’s subsequent temporal logic of programs (1977). McCarthy cites it in Elephant 2000 as prior art on verifying programs whose specifications are not input-output but ongoing-behaviour — exactly the shape of Elephant programs, whose speech-act semantics concerns sequences of illocutions over time rather than a single terminating output.

Key Ideas

Cyclic programs: non-terminating sequential/concurrent programs whose correctness is about sustained behaviour, not terminal output.
Eventual behaviour: replaces input-output correctness with properties like “infinitely often,” “eventually,” “persistently.”
Proof method: invariant-style reasoning adapted to the cyclic setting, supporting both sequential and concurrent programs.
Precursor to temporal logic: the informal modalities here are systematised in Pnueli’s 1977 temporal logic of programs.
Concurrency: the method handles cooperating concurrent processes, anticipating Owicki/Gries-style proof rules.

Connections

Elephant 2000 - A Programming Language Based on Speech Acts — McCarthy cites this as prior art on verifying non-terminating / reactive programs
An Application of a Method for Analysis of Cyclic Programs — Francez’s 1978 TSE companion paper applying the method to Dijkstra’s on-the-fly garbage collector
Program Verification
Formal Verification
Hoare Logic
Assigning Meanings to Programs
Verification Condition

Conceptual Contribution

Claim: Non-terminating (cyclic) programs admit a rigorous correctness theory if one replaces the input-output correctness paradigm with a proof method over eventual behaviour — properties of the infinite execution — and this method extends to concurrent cyclic programs.
Mechanism: Generalised invariants characterising the sustained behaviour, combined with proof rules that discharge eventual/persistent properties directly rather than deriving them from pre/post pairs. For concurrent programs, the method handles process interaction via cooperation conditions.
Concepts introduced/used: Program Verification, Formal Verification, Hoare Logic, Verification Condition
Stance: methodological / verification-foundations
Relates to: A key transitional work between Floyd-Hoare partial-correctness verification (Assigning Meanings to Programs, Hoare Logic) and Pnueli’s subsequent temporal logic of programs (1977). McCarthy’s Elephant 2000 - A Programming Language Based on Speech Acts positions the paper as evidence that programs whose correctness is an ongoing speech-act record (rather than a terminal output) are already within verification’s reach — the “program as logical sentence” stance just extends this to the speech-act level.

Tags

What is it to Understand a Directive Speech Act

What is it to Understand a Directive Speech Act?

Reference: Andreas Dorschel (1989). Australasian Journal of Philosophy 67(3): 319-340. URL (DOI: 10.1080/00048408912350161). No open-access PDF located; publisher page HTML-only. Cited in McCarthy’s Elephant 2000 - A Programming Language Based on Speech Acts.

Summary

Dorschel investigates what it takes for a hearer to understand a directive speech act (command, request, order). The dominant programme — truth-conditional semantics extended to directives via “conditions of fulfilment”, “compliance”, or “satisfaction” (Searle, Vanderveken, and others) — treats understanding a directive as grasping the conditions under which the world would be made to fit the words. Dorschel argues this parallel to truth-conditional assertoric semantics is defective: directive understanding is not grasp of satisfaction conditions alone but requires the hearer to recognise the speaker’s authority-claim and the social-normative context within which compliance would count as compliance.

The paper is cited in McCarthy’s Elephant 2000 as philosophical backing for treating directive speech acts (requests, offers, permissions) as having authority/normative preconditions that a program’s specification must respect — the “authority” strand of Elephant’s happy-performance criterion.

Key Ideas

Critique of compliance-conditional semantics: satisfaction conditions (world-to-word direction of fit) do not by themselves explain what a hearer grasps when understanding a directive.
Authority-claim as part of illocutionary uptake: recognising a directive involves recognising the speaker’s claim to be in a position to direct — a normative precondition, not merely a truth-theoretic one.
Social-institutional context: compliance is constituted relative to institutional roles; directive understanding requires tracking those roles.
Parallel to assertion is misleading: the symmetry between truth-conditional assertoric semantics and compliance-conditional directive semantics papers over the normative asymmetry between word-to-world and world-to-word acts.

Connections

Elephant 2000 - A Programming Language Based on Speech Acts — McCarthy cites Dorschel on the authority/normative side of directive acts
Foundations Of Illocutionary Logic — Searle & Vanderveken, the compliance-conditional programme Dorschel critiques
Speech Act Theory
Speech Acts
Performatives
Speech Acts - An Essay in the Philosophy of Language
Illocutionary Force
Direction of Fit
Agent Communication And Institutional Reality

Conceptual Contribution

Claim: Understanding a directive speech act cannot be reduced to grasping its conditions of compliance; it requires the hearer to recognise the speaker’s authority-claim and the social-institutional context within which compliance counts as compliance.
Mechanism: By analysing cases where the compliance conditions are transparent yet the directive is not understood (because the authority-claim is unrecognised or rejected), Dorschel dissociates satisfaction-conditional grasp from directive understanding, forcing the normative layer into the analysis.
Concepts introduced/used: Performatives, Illocutionary Force, Direction of Fit, Speech Act Theory, Institutional Reality
Stance: critical / philosophical
Relates to: Provides a philosophical bridge between pure illocutionary-logic accounts (Foundations Of Illocutionary Logic) and institutional-reality accounts (Agent Communication And Institutional Reality). In the ACL trajectory, the Dorschel critique anticipates the standard complaint against mentalistic ACL semantics (sincerity-condition appeals presuppose exactly the authority/commitment layer they try to reduce) and motivates the commitment-based turn formalised in later ACL work.

Tags

Epistemological Fault Lines Between Human and Artificial Intelligence

Reference: Quattrociocchi, W., Capraro, V., & Perc, M. (2025). Epistemological Fault Lines Between Human and Artificial Intelligence. arXiv:2512.19466v1 [cs.CY]. URL

Summary

The paper argues that the surface-level alignment between LLM outputs and human judgment masks a deep structural mismatch in how the two arrive at their answers. Tracing a historical shift from symbolic AI and information-retrieval systems — which treated language as a vehicle for explicit propositional content — to large-scale generative transformers, the authors observe that LLMs do not “reason under beliefs about the world” but rather perform stochastic pattern-completion over high-dimensional embeddings of linguistic transitions. The appearance of rationality is a by-product of having absorbed the human linguistic record, not of having the cognitive machinery that originally produced it.

To make the mismatch concrete, the authors decompose judgment into seven stages and show that at each stage the human and LLM pipelines follow fundamentally different trajectories: (1) sensory/social input vs. textual input; (2) perceptual-situational parsing vs. tokenization; (3) memory/intuitions/learned concepts vs. statistical pattern-recognition in embeddings; (4) emotions/motivations/goals vs. statistical inference via neural layers; (5) reasoning vs. textual context integration; (6) metacognitive calibration vs. forced confidence and hallucination; (7) value-sensitive judgment vs. probabilistic next-token prediction. Each pair corresponds to one of seven epistemological fault lines: Grounding, Parsing, Experience, Motivation, Causality, Metacognition, Value. These fault lines are structural, not bugs to be patched: they are consequences of the architecture itself, so fluency-on-the-surface keeps producing confidence-like outputs even where no justifying process exists.

The central positive construct is Epistemia: a structural condition in which linguistic plausibility substitutes for epistemic evaluation. Under Epistemia, a system produces answers that are syntactically well-formed, semantically fluent, and rhetorically convincing without instantiating the processes by which beliefs are normally formed, tested, or revised. The harm is not that the system is factually wrong — it often is not — but that the user is placed in a position of epistemic passivity where justification is displaced by pre-packaged persuasion. The paper closes by arguing for epistemic evaluation beyond surface alignment (benchmarks that probe calibration, counterfactual sensitivity, and refusal, not just accuracy), epistemic governance beyond behavioural alignment (regulating categories of epistemic failure rather than individual outputs), and epistemic literacy beyond critical thinking (teaching users procedural safeguards against surrogate evaluation, not merely scepticism).

Key Ideas

Human and LLM judgment pipelines diverge at every stage, not only at the output; the apparent similarity is a linguistic-plausibility artefact.
Seven epistemological fault lines — Grounding, Parsing, Experience, Motivation, Causality, Metacognition, Value — each corresponding to a structural divergence in the pipeline.
Epistemia: linguistic plausibility substitutes for epistemic evaluation; a regime in which answers arrive without the labour of justification.
Hallucination is not a bug but a structural consequence of a system that must always produce an output and lacks metacognition to suspend judgment.
LLMs have no causal, counterfactual, or value-grounded evaluation; they integrate textual context to produce surface-level plausible continuations.
Epistemia is not reducible to automation bias or over-trust — it is an architectural condition: users interact with systems that lack the internal machinery for forming, holding, or revising beliefs.
Three responses: epistemic evaluation beyond surface alignment; epistemic governance beyond behavioural alignment; epistemic literacy beyond critical thinking.

Connections

Conceptual Contribution

Claim: Linguistic fluency in LLMs is not evidence of judgment; the two pipelines diverge along seven structural fault lines, and their surface similarity produces a systemic epistemic pathology — Epistemia — in which linguistic plausibility replaces the labour of evaluation.
Mechanism: Decompose judgment into seven stages (input → parsing → memory/concepts → motivation → reasoning → metacognition → value) and compare the human pipeline (sensory-social, grounded, embodied, metacognitively monitored, value-sensitive) with the LLM pipeline (textual, tokenized, statistically embedded, forced to output, probabilistic). Identify the divergence at each stage as a fault line; show each produces characteristic failures (grounding error, tokenization drift, spurious associations, missing motivational significance, counterfactual blindness, hallucination, absent accountability). Frame the aggregate as Epistemia — an architectural regime, not a user-side bias.
Concepts introduced/used: Epistemia, Grounding, Hallucination, Chinese Room Argument, Symbol Grounding Problem, Intentional Stance, Intelligent Agents Theory and Practice
Stance: philosophical / critical-theoretic perspective on LLMs
Relates to: Extends Symbol Grounding Problem and the Searle/Dennett debates (Chinese Room Argument, Minds Brains and Science, True Believers - The Intentional Strategy and Why It Works) to the large-model era; sharpens critiques in Why AI Agents Communicate In Human Language; counterpoint to the scaling optimism of The Bitter Lesson; foundational framing for the “what is an LLM judgment, actually?” question that underlies LLM Agents evaluation.

Counts-As Relation

Jones and Sergot’s (1993) formal connective for the relation by which a brute (physical, computational) event is treated by an institution as constituting a particular institutional event. Written A ⇒s B and read “in institution s, A counts as B.” A piece of paper of certain composition signed in certain ways counts as a contract in the legal institution; a byte-sequence on the wire conforming to a dialect contract counts as a binding commitment in an agent society. The connective is institution-relative, non-monotonic (additional context facts can defeat the count-as), and constitutive (count-as facts partly define what the institution is). Combined with deontic operators (obligation, permission, prohibition), counts-as is the formal vocabulary of normative systems. For CBCL, a dialect contract is precisely a counts-as specification: it stipulates which wire events, in this dialect, count as which institutional commitments.

In this vault

Jones-Sergot Normative Systems — the founding chapter
Constitutive Rules
Regulative Rules
Institutional Facts
Deontic Logic
An Ontology for Commitments in Multiagent Systems - Singh
Commitment-based Semantics
Speech Act Theory
How to Do Things with Words
Speech Acts - An Essay in the Philosophy of Language
Agent Communication And Institutional Reality
Convention - Lewis
Languages and Language - Lewis
Speaks-For Calculus — a counts-as fragment (this credential counts as authority to assert on behalf of)
CBCL - Safe Self-Extending Agent Communication

Jones-Sergot Normative Systems

On the Characterisation of Law and Computer Systems: The Normative Systems Perspective

Reference: Jones, A. J. I. & Sergot, M. (1993). On the Characterisation of Law and Computer Systems: The Normative Systems Perspective. In J.-J. Ch. Meyer & R. J. Wieringa (eds.), Deontic Logic in Computer Science: Normative System Specification (pp. 275–307). John Wiley & Sons. Semantic Scholar record · DEON 1991 precursor (workshop paper, more accessible) · SEP: deontic logic

Summary

Jones and Sergot’s chapter is the founding statement of the normative systems programme in AI and computer science — the move that takes computer systems (including multi-agent systems) seriously as normative artefacts whose behaviour can be analysed in the same vocabulary as legal systems. The central technical contribution is a formal account of the counts-as relation: the relation by which a brute (physical, computational) event is treated by an institution as constituting a particular institutional event. A piece of paper of certain composition, signed in certain ways, counts as a contract in the legal institution; a particular sequence of bytes on the wire, conformant to a particular protocol, counts as a binding promise in an agent society. The counts-as relation is the bridge between brute facts and institutional facts, between syntactic events and their normative significance.

The paper develops counts-as as a conditional connective ⇒s indexed by an institution s: A ⇒s B reads “in institution s, A counts as B.” The counts-as connective is not classical material implication: it is institution-relative, non-monotonic (additional facts about the institutional context may defeat the count-as), and constitutive (the count-as relation is partly what makes the institution be the institution it is). The framework lets the authors model standard legal phenomena — speech-acts that create institutional roles, signing-procedures that count as enacting law, delegation that lets an agent’s act count as another’s, and the distinction between rules that regulate existing institutional activity and rules that constitute the institutional categories themselves. The Wieringa–Meyer volume’s surrounding chapters develop deontic logics (obligation, permission, prohibition) that combine with counts-as to specify normative systems.

For CBCL and the public-semantics line, the counts-as relation is the missing institutional bridge between the wire format and the commitment-state. A CBCL dialect contract is precisely a counts-as specification: in this dialect, this byte-sequence on the wire counts as a binding commitment with these debtor / creditor / condition / context slots. Without counts-as, the move from “the agent emitted these bytes” to “the agent has incurred this commitment” is unprincipled; with counts-as, it is a well-defined institutional bridge inheriting decades of deontic-logic infrastructure. The paper is also the unification point for the broader normative MAS literature — Singh’s commitments, Fornara–Colombetti–Verdicchio’s institutional ACL, and the broader European MAS deontic tradition (Boella, van der Torre, Castelfranchi, Carmo–Jones) all sit downstream.

Key Ideas

Counts-as relation ⇒s: an institution-indexed conditional. A ⇒s B reads “in institution s, A counts as B.” The bridge between brute facts (physical, computational events) and institutional facts (contracts, commitments, roles).
Constitutive vs regulative rules: counts-as rules are constitutive — they partly define what the institution is. Regulative rules (deontic operators: obligation, permission, prohibition) presuppose the institutional categories and govern behaviour within them. The constitutive/regulative distinction goes back to Searle 1969; Jones–Sergot give it a formal home.
Non-monotonic, institution-relative, defeasible: counts-as is not classical implication. Additional facts about the institutional context (a forged signature, an invalid delegation chain) may defeat a counts-as that would otherwise hold.
Institutions as the unit of normative analysis: an institution is a coherent body of constitutive and regulative rules. Computer systems can host institutions exactly as legal systems do.
Empowerment: certain institutional roles are empowered to perform certain acts (the judge can pronounce sentence; the agent in role seller can issue invoices). Empowerment is a counts-as fact about which acts of which role-holders count as which institutional acts.
Normative-position analysis: drawing on Hohfeld’s analysis of fundamental legal conceptions (right / duty / privilege / liability / power / immunity), the paper sketches how each Hohfeldian relation is reconstructible from constitutive-and-regulative-rule analyses.
Bridge to deontic logic: combines naturally with standard deontic operators (Os “it is obligatory in s that”, Ps “it is permitted in s that”, etc.) to give a full normative-system specification language.

Connections

Conceptual Contribution

Claim: Legal systems and computer systems can be analysed in a single formal framework — the normative system — anchored by the counts-as relation, a constitutive bridge from brute facts to institutional facts. Deontic operators (obligation, permission, prohibition) then operate on the institutional categories the counts-as relation establishes.
Mechanism: Introduce the institution-indexed conditional ⇒s (counts-as in institution s), reflexive and transitive but non-monotonic and institution-relative. Distinguish constitutive rules (which establish institutional categories via counts-as) from regulative rules (which apply deontic operators within the institutional categories). Combine with standard deontic operators to specify the full normative system. Sketch how Hohfeld’s fundamental legal conceptions reduce to constitutive/regulative patterns.
Concepts introduced/used: Counts-As Relation ⇒s, Constitutive Rules, Regulative Rules, Institutional Facts, Brute Facts, Empowerment, Hohfeldian Analysis, Normative Position, Deontic Logic.
Stance: foundational technical chapter.
Relates to: The institutional bridge missing from the commitment-based semantics line — a CBCL dialect contract is a counts-as specification (this byte-sequence, in this dialect, counts as this commitment), and without counts-as the move from wire events to institutional commitments is unprincipled. Pairs directly with Singh 1999 (commitments as the normative substrate) and with Fornara, Colombetti & Verdicchio (institutional ACL semantics). The philosophical foundation is Searle 1969’s constitutive/regulative distinction and Searle 1995’s Construction of Social Reality (counts-as as social ontology); Jones–Sergot give the formal home. Compatible with Brandomian inferentialism as a layer: counts-as gives the institutional ontology, deontic scorekeeping gives the dynamics of commitment-undertaking within that ontology. The speaks-for calculus of Lampson et al. is a counts-as fragment (this credential counts as authority to assert on behalf of). For CBCL, counts-as is the formal-vocabulary answer to “what does dialect installation actually do normatively?” — install rules give wire events institutional meaning.

Convention of Truthfulness

David Lewis’s coordination-equilibrium analysis of meaning (Convention, 1969): a language is sustained by a convention among speakers to be truthful in it. Game-theoretic counterpart to Meaning As Use.

In this vault

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).

Common Knowledge (Convention)

The infinite hierarchy of mutual expectation introduced by Lewis (1969) and rediscovered by Aumann (1976) in game theory and Halpern–Moses (1990) in distributed systems: A knows p, A knows that B knows p, A knows that B knows that A knows p, … all the way up. A convention is sustained by common knowledge of the regularity. The construction has the same mathematical content in three independent fields — Lewis-style social philosophy, game theory, and distributed-systems epistemology — and is unattainable in fully asynchronous distributed systems (Halpern & Moses), with deep consequences for what coordination protocols can achieve.

In this vault

Convention (Lewis)

David Lewis’s (1969) game-theoretic analysis of conventions: a regularity R in the behaviour of a population is a convention iff almost everyone conforms to R, almost everyone expects almost everyone else to conform, almost everyone prefers conforming on the assumption that others conform, and some alternative regularity could equally have served. Sustained by Mutual Expectation / common knowledge. Foundational analysis of how shared meaning, currency, and social roles arise without explicit agreement.

In this vault

Convention - Lewis

Convention: A Philosophical Study

Reference: Lewis, D. K. (1969). Convention: A Philosophical Study. Harvard University Press, Cambridge MA. (Reprinted 2002, Blackwell.) SEP entry on Convention · Wiley publisher page (book; no full-text OA.)

Summary

Lewis offers the first rigorous game-theoretic analysis of how shared conventions — including, paradigmatically, the conventions of language — arise and sustain themselves among rational agents without explicit agreement. The book opens by defining a coordination problem: a situation in which several agents have multiple equilibria available, all parties prefer reaching some equilibrium to none, and they are largely indifferent (or have non-conflicting preferences) over which equilibrium they reach. Lewis’s central thesis is that a convention is a regularity in behaviour that is one solution to a coordination problem, sustained by mutual expectation — each party expects the others to follow the regularity, expects the others to expect them to follow it, and so on up an infinite hierarchy that Lewis was the first to formalise as common knowledge. The book applies this analysis to driving conventions (drive on the right vs left), signalling, currency, and at length to language: the conventions of meaning are coordination equilibria sustained by mutual expectation in a population of speakers; semantic content is what would be the case if the convention were followed. Lewis’s framework supplies the philosophical foundation for every later treatment of emergent and negotiated meaning — emergent-communication research in MAS and deep learning, the ACL evolution programme, and the language-games tradition (Wittgenstein operationally, Steels formally) all proceed in the conceptual space Lewis defined. The common-knowledge construction is independently a foundational result for distributed-systems theory (Halpern & Moses 1990) and game theory (Aumann 1976).

Key Ideas

Coordination problem: a strategic situation with multiple Pareto-comparable equilibria where no party prefers a non-equilibrium outcome and the parties’ preferences over equilibria largely coincide. The classical examples — driving side, meeting place — generalise to language, money, social roles.
Convention as a self-sustaining regularity: a regularity R is a convention iff (i) almost everyone conforms to R, (ii) almost everyone expects almost everyone else to conform to R, (iii) almost everyone prefers conforming on the assumption that others conform, and (iv) some alternative regularity could have been the convention instead (no party of the convention is intrinsically preferred).
Common knowledge: the infinite hierarchy of mutual expectation that sustains a convention — A knows that B follows R; A knows that B knows that A follows R; and so on. Lewis was the first to give a formal account of this in social terms; the construction was rediscovered by Aumann in game theory and Halpern–Moses in distributed systems.
Salience and precedent as convention selectors: when multiple equilibria are available, salient features (Schelling’s focal points, see The Strategy of Conflict) and historical precedent select among them. There is no rationality-driven argument for which equilibrium becomes conventional; the answer is contingent on saliency.
Language as convention: meaning is what would obtain if the convention were followed. Truth-conditions, communicative force, and reference are all conventionally fixed — but the convention is not arbitrary, it is sustained by everyone’s expectation that everyone else will use words a particular way.
Conventions vs explicit agreements: Lewis argues that explicit agreement is neither necessary nor sufficient for convention — many conventions arise without agreement (precedent does the work) and many agreements never become conventions (because mutual expectation does not develop).
Population vs pair: conventions are population-level facts; one cannot have a convention with a single partner. Mutual expectation must extend across the relevant community for the regularity to be convention-grade.

Connections

Conceptual Contribution

Claim: Conventions — including the conventions of language — are best analysed as solutions to coordination problems sustained by mutual expectation (formally, common knowledge) in a population of rational agents. There is nothing arbitrary about the convention’s function, but the particular regularity that becomes conventional is contingent on salience, precedent, and historical accident.
Mechanism: Game-theoretic analysis of coordination problems with multiple equilibria; definition of convention via four clauses (conformity, mutual expectation, conditional preference, alternativeness); explicit construction of common knowledge as an infinite hierarchy of expectations; application to driving conventions, signalling, currency, and at length to language semantics.
Concepts introduced/used: Coordination Game, Convention (Lewis), Common Knowledge (Convention), Mutual Expectation, Focal Point (via dialogue with Schelling), Salience, Precedent, Convention vs Agreement.
Stance: foundational philosophical monograph.
Relates to: Direct philosophical foundation for every later treatment of emergent meaning and negotiated language: Steels’ language games are operational realisations of Lewis’s coordination-problem analysis with explicit interaction protocols; Lazaridou et al. and the deep-learning emergent-communication line train neural agents to converge on Lewis-style conventions in referential games. The ACL-evolution programme (Toward Automated Evolution of ACLs, Towards Automating the Evolution of Linguistic Competence) treats the ACL itself as an evolving Lewis-convention. Lewis’s common-knowledge construction is independently the foundation of Halpern & Moses 1990 in distributed systems and Aumann (1976) in game theory — distributed protocols and conventional language share the same mathematical object. The framework also clarifies what is at stake in the Mentalistic Semantics vs Public Semantics debate in ACLs: Lewis-style conventions are public-semantics objects (mutual-expectation regularities) but their stability depends on something close to mentalistic conditions (each agent’s expectations about others’ beliefs), so the two semantic families are dual aspects of the same phenomenon rather than competitors. Why AI Agents Communicate In Human Language revisits Lewis from the LLM-agent angle: natural language is a particular Lewis-convention (a contingent equilibrium) and not necessarily the optimal one for inter-agent coordination.

Tags

#convention #coordination #common-knowledge #lewis #philosophy-of-language #foundations #emergent-meaning

Context Set

Stalnaker’s formalisation of Common Ground: the set of possible worlds compatible with everything mutually presupposed by conversational participants. Assertions narrow the context set.

In this vault

Common Ground

Stalnakerian notion: the body of propositions mutually presupposed by participants in a conversation; sentences update the common ground when accepted. Foundational to Dynamic Semantics and to Pragmatic Presupposition.

In this vault

Assertion - Stalnaker

Assertion

Reference: Stalnaker, R. C. (1978). Assertion. In P. Cole (ed.), Syntax and Semantics 9: Pragmatics (pp. 315–332). New York: Academic Press. Reprinted in Stalnaker, Context and Content (Oxford UP 1999). PhilPapers record · SEP: pragmatics · SEP: presupposition

Summary

Stalnaker’s “Assertion” gives the canonical update-semantics account of what a speech act of asserting does, framed in terms of a common ground of mutually accepted propositions shared between conversational participants and a context set of possible worlds compatible with that common ground. To assert a proposition p is, prima facie, to propose that p be added to the common ground — equivalently, to propose that the context set be narrowed to its intersection with the set of worlds in which p is true. The hearer either accepts (the context set is updated) or challenges (the proposal stalls, the common ground is unchanged). The picture is symmetric, trace-checkable, and pragmatic: it tells you what an assertion does without taking a stand on the speaker’s inner mental state.

The paper develops three essential effects of assertion. (1) An assertion of p adds p to the common ground unless it is challenged. (2) The proposition asserted should be determinate — true or false at every world in the context set; if not, the context set must be re-coordinated first (anticipating the accommodation mechanism worked out in Lewis 1979). (3) The proposition asserted should partition the context set non-trivially: not be common-ground-true already, not be common-ground-false already, and not be context-incoherent. This third effect is the seed of Gricean informativeness as a built-in feature of the dynamics rather than a separately stated maxim. The framework anticipates the entire dynamic semantics tradition (Heim, Kamp, Veltman) and is the operational counterpart of Grice 1975: where Grice gives maxims governing rational conversation, Stalnaker gives the update mechanics conversation operates on.

For agent communication, Stalnaker is the philosopher who most directly anticipates trace-checkable assertion semantics. The common ground is a publicly observable object — what has been said and accepted — and assertion is a publicly observable update operation on it. There is no need to inspect any agent’s beliefs; the semantic content of an assertion is given by the update it proposes, and conformance with that semantics is checkable from a transcript. The natural pairing in this vault is with Singh 1998 on social-agency semantics, Fornara & Colombetti on commitment-based operational semantics, and ultimately CBCL — the common ground / context-set apparatus is precisely the kind of shared, monotone, trace-checkable object that monotone-verdict commitment protocols want.

Key Ideas

Common ground: the body of propositions mutually accepted (not necessarily believed) for purposes of conversation. The mathematical reflex is the context set — the set of worlds compatible with the common ground.
Assertion as context-set update: an assertion of p proposes narrowing the context set to the intersection with [[p]]. If accepted, the update goes through; if challenged, it stalls.
Three essential effects of assertion (the “essential effect” inventory): (i) the asserted proposition should be added to the common ground on acceptance; (ii) it must be determinate over the context set (true or false at each world); (iii) it must partition the context set non-trivially (informative).
Diagonalisation / two-dimensional accommodation: when an assertion’s content varies across worlds in the context set, the hearer can use the diagonal proposition — the function picking out, at each world, the content the assertion would have at that world — to recover a determinate update. This is the engine behind much of dynamic semantics’ treatment of indexicals and modals.
Pragmatic presupposition: a speaker presupposes q iff, in uttering an assertion, the speaker takes q to be in the common ground. Presupposition is a property of speakers in contexts, not of sentences in models — the move that allows accommodation to be modelled cleanly.
Context set is a public object: the framework is symmetric across participants — neither side has privileged access. Trace-checkability falls out.

Connections

Conceptual Contribution

Claim: Assertion is best modelled as a publicly observable update operation on the common ground of mutually accepted propositions. The semantic content of an assertion is determined by which possible worlds it eliminates from the context set, with no recourse to the speaker’s inner mental state required.
Mechanism: The common ground is the body of propositions the participants mutually accept for purposes of conversation; the context set is its set-theoretic reflex (worlds compatible with the common ground). An assertion of p proposes intersecting the context set with [[p]]. The three essential effects (informativeness, determinacy, acceptance-by-default) govern well-formed assertion; diagonalisation handles cases where content varies across the context set.
Concepts introduced/used: Common Ground, Context Set, Update Semantics, Diagonal Proposition, Pragmatic Presupposition, Accommodation, Essential Effect of Assertion.
Stance: foundational philosophical paper / canonical dynamic-pragmatic theory.
Relates to: Operational counterpart of Grice 1975 — where Grice supplies maxims of rational conversation, Stalnaker supplies the mechanics (context-set update) that conversation manipulates. Genealogically the foundation of the dynamic semantics tradition (Heim FCS, Kamp DRT, Veltman update semantics). For agent communication, the framework is the direct philosophical antecedent of public-semantics / commitment-based approaches: the common ground is a publicly observable, monotone, trace-checkable object — exactly the kind of state Singh’s social-agency semantics, Fornara & Colombetti’s operational commitment semantics, and CBCL’s ledger want. The deeper philosophical pair is Brandom: Stalnaker’s common-ground update is one of the two canonical formal models of deontic scorekeeping (the other being argumentation-style commitment stores after Hamblin).

Making It Explicit - Brandom

Making It Explicit: Reasoning, Representing, and Discursive Commitment

Reference: Brandom, R. B. (1994). Making It Explicit: Reasoning, Representing, and Discursive Commitment. Harvard University Press, Cambridge MA. ~700 pp. URL (Part One PDF, author-hosted) · Internet Archive · SEP: inferentialism

Summary

Making It Explicit is Brandom’s full statement of the inferentialist programme — the long, technical book that Articulating Reasons (2000) compresses into six lectures. Where the shorter book is the entry point, MIE is the reference manual: it works out, at the level of detail required to settle objections, how the basic discursive practice of giving and asking for reasons can serve as the foundation for an entire theory of meaning — including the parts (reference, truth, objectivity, intentionality) that representationalism takes as primitive. The book unfolds in two large parts: a pragmatic part, in which Brandom develops the deontic scorekeeping model of assertion and shows how it can recover everything one wants from a notion of speech act without recourse to mental states, and a semantic part, in which the recovery of singular terms, predicates, propositional content, and ultimately the de re / de dicto distinction is carried out in scorekeeping terms.

The book’s intellectual ancestry is openly stated: Quine on semantic holism and the analytic–synthetic collapse, Sellars on the Myth of the Given and the space of reasons, and Wittgenstein on meaning as use and language-games, all metabolised through a Hegelian appreciation of the social character of normativity. The technical innovation is to take Sellars’s insight — that the difference between a parrot trained to say “that’s red” and a person saying it is not phenomenological but inferential (a person can deploy the claim in the game of reasons) — and turn it into a full-scale semantic theory. The result is the most developed semantics-without-minds in the analytic tradition: a worked-out alternative to the mentalistic picture that has dominated philosophy of language since Searle and the early Cohen–Levesque tradition in ACL design.

For the agent-communication line, MIE is the place to send sceptics. The standard worry about public-semantics / commitment-based ACL design is that it gives up on “real” meaning in exchange for trace-checkability. Brandom’s answer, in a thousand pages, is no: deontic scorekeeping is not a thin behavioural surrogate for a richer mentalistic semantics — it is the foundation from which mentalistic talk is derivable. If Brandom is right, then Singh 1998’s move from BDI semantics to social-commitment semantics is not a retreat under pressure of verifiability; it is the correct place to ground meaning, with verifiability as a downstream bonus.

Key Ideas

Deontic scorekeeping as the basic discursive practice: speakers track, for themselves and each other, commitments (claims undertaken), entitlements (claims one is licensed to undertake), and incompatibilities (pairs of commitments that cannot both be entitled). Assertion is the basic move; the score is the running ledger.
Material inference as ground floor: inferences whose goodness is part of the meaning of the constituent terms (Pittsburgh is west of Princeton ⇒ Princeton is east of Pittsburgh) are prior to formal logical inference. Logic is a downstream expressive resource.
The expressive role of logic: conditionals, negation, and other logical vocabulary serve the function of making implicit inferential commitments explicit as new claims. This is the expressive (not foundational) role of logic.
De re / de dicto and singular terms: even classically representationalist topics — quantifying in, anaphora, singular reference — are reconstructed in scorekeeping terms, without taking reference as primitive.
Sapience without sentience: the distinction between concept-mongering creatures and the rest of nature lies in participation in the game of giving and asking for reasons, not in phenomenology.
Normative pragmatism: the social practice of holding one another accountable for commitments is the unanalysed foundation. Norms are instituted by the practice of scorekeeping, not read off antecedent facts.
Anti-representationalist but not anti-realist: truth, objectivity, and a mind-independent world are recovered from the perspectival structure of scorekeeping — not given up.

Connections

Conceptual Contribution

Claim: Linguistic meaning, including reference and objectivity, can be fully reconstructed from the social practice of deontic scorekeeping — undertaking, attributing, and tracking commitments and entitlements — without taking any mental state or representational primitive as basic.
Mechanism: A two-part construction. Pragmatic part: the basic act of asserting is the undertaking of a commitment; scorekeeping practices track commitments, entitlements, and incompatibilities. Semantic part: propositional content is the inferential role of a sentence in the scorekeeping practice; singular terms, predicates, de re / de dicto, and reference are recovered from the structure of perspectival scorekeeping. Logic is an expressive resource that makes implicit inferential commitments explicit.
Concepts introduced/used: Inferentialism, Deontic Scorekeeping, Material Inference, Commitment (Brandom), Entitlement (Brandom), Incompatibility (Brandom), Expressive Role of Logic, Sapience vs Sentience, De Re vs De Dicto, Normative Pragmatism, Semantics-Without-Minds.
Stance: foundational philosophical treatise.
Relates to: The book-length statement of which Articulating Reasons is the readable extract; read MIE only when the lectures leave a question unresolved. Genealogically continues the Wittgenstein / Sellars / Quine line — Sellars’s Myth of the Given is the antecedent move; Brandom’s scorekeeping is its destination. For agent communication, MIE is the deep philosophical underwriting of the public-semantics / commitment-based programme — Singh, Fornara & Colombetti, Yolum & Singh, and ultimately CBCL can all be read as engineering instantiations of fragments of the MIE picture.

Semantics-Without-Minds

The position — descended from Wittgenstein / Sellars / Brandom — that a complete theory of linguistic meaning can be built from publicly observable practice without taking any mental state (belief, intention, desire, qualia) as semantic primitive. Sellars’s Myth of the Given argument blocks the move to pre-conceptual inner content; Wittgenstein’s rule-following considerations block the move to private semantic rules; Brandom’s Deontic Scorekeeping supplies the positive replacement. The position is the philosophical underwriting of the Public Semantics / Commitment-based Semantics programme in agent communication, and the cleanest answer to the worry that protocols built on observable commitments are “thin behavioural surrogates” for “real” mentalistic meaning. They are not — they are the foundation.

In this vault

Deontic Scorekeeping

Brandom’s model of discursive practice: each speaker maintains a score on every other tracking which commitments that speaker has undertaken, which entitlements they hold, and which incompatibilities are in play. To assert is to undertake a commitment and license attribution back to oneself; the meaning of a sentence is exhaustively given by how its assertion changes the score. The model is the formal core of Inferentialism: it shows how an entire theory of meaning, including reference and objectivity, can be built from publicly observable normative bookkeeping with no recourse to mental states. Stalnaker’s Common Ground / Context Set update model of assertion and Hamblin-style commitment stores from formal dialectic are the two other canonical formal models of the same phenomenon.

In this vault

Articulating Reasons - Brandom
Making It Explicit - Brandom
Inferentialism
Material Inference
Semantics-Without-Minds
Assertion - Stalnaker — Common Ground update is the operational analogue
Common Ground
Fallacies - Hamblin — Commitment Store from formal dialectic
Commitment in Dialogue
An Ontology for Commitments in Multiagent Systems - Singh — ACL-side instantiation
A Commitment-Based Approach to Agent Communication
Commitment Machines - Yolum and Singh
Public Semantics
Commitment-based Semantics
CBCL - Safe Self-Extending Agent Communication

Inferentialism

The semantic view, developed in its modern form by Robert Brandom (building on Sellars, Wittgenstein, and Quine), that the meaning of a sentence is its role in the inferential practices of a community of speakers — what asserting it entitles you to assert, what claims it is incompatible with, what would entitle you to assert it. Reference, truth, and representational content are downstream of inferential articulation rather than upstream of it. The slogan: meaning is use, formalised. The position is the philosophical underwriting of the Public Semantics / Commitment-based Semantics line in agent communication — a worked-out Semantics-Without-Minds that lets a wire-format trace carry full semantic content without invoking sender or receiver mental states.

In this vault

Articulating Reasons - Brandom — entry point (the 1998 Locke Lectures in book form)
Making It Explicit - Brandom — the full treatise
Empiricism and the Philosophy of Mind - Sellars — Sellars’s Myth of the Given is the historical hinge
Philosophical Investigations - Wittgenstein — Meaning As Use / language-games
Two Dogmas of Empiricism - Quine — Semantic Holism
Material Inference
Deontic Scorekeeping
Semantics-Without-Minds
Public Semantics
Mentalistic Semantics
Commitment-based Semantics
ACL Rethinking Principles — Singh’s social-agency programme is the ACL-side analogue
An Ontology for Commitments in Multiagent Systems - Singh
CBCL - Safe Self-Extending Agent Communication — engineering realisation at wire-format granularity

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.

Space of Reasons

Wilfrid Sellars’ phrase: the normative domain in which beliefs and assertions stand in relations of justification and entitlement, distinguished from the causal order of nature. Central to Pittsburgh School philosophy.

In this vault

Myth of the Given

Sellars’s name (in EPM 1956) for the foundationalist idea — common across British empiricism, sense-datum theory, phenomenology, and parts of analytic epistemology — that knowledge must rest on a foundation of preconceptual sensory contents (the “given”) that are both non-inferentially known and epistemically authoritative. Sellars argues the picture is incoherent: anything that can serve to justify a belief is already conceptually articulated, and so cannot be preconceptual. Epistemic standing lives in the Space of Reasons, not in a layer of bare data outside it. The argument is the historical hinge of the inferentialist turn — the move that makes Semantics-Without-Minds philosophically defensible by foreclosing the alternative of grounding meaning in pre-discursive mental content.

In this vault

Empiricism and the Philosophy of Mind - Sellars

Empiricism and the Philosophy of Mind

Reference: Sellars, W. (1956). Empiricism and the Philosophy of Mind. In Feigl & Scriven (eds.), The Foundations of Science and the Concepts of Psychology and Psychoanalysis (Minnesota Studies in the Philosophy of Science, vol. I, pp. 253–329). University of Minnesota Press. Reissued as a standalone book in 1997 with study guide by Brandom. URL (Ditext transcription) · SEP: Sellars

Summary

Sellars’s Empiricism and the Philosophy of Mind — often known by the abbreviation EPM — is the founding text of the Pittsburgh school of philosophy (Sellars, Brandom, McDowell) and the source of the move that makes semantics without minds possible. The paper’s central target is the Myth of the Given: the idea that knowledge must rest on a foundation of preconceptual, given sensory contents (sense data, qualia, immediate awareness) which are both non-inferential and epistemically authoritative. Sellars argues that this picture is incoherent: anything that could be epistemically authoritative — anything that could justify a belief — must already be conceptually articulated, and so cannot be preconceptual. There is no epistemic free lunch at the periphery; all knowledge lives inside the space of reasons.

The argument unfolds across sixteen sections. The early sections deconstruct sense-datum theory; the middle sections develop Sellars’s positive account of looking-talk (looks-red is parasitic on is-red, not the other way around); the late sections develop the famous Jonesean myth in which thoughts and inner episodes are introduced as theoretical posits modelled on overt speech, with sensory impressions as further theoretical posits modelled on the perceptible properties of physical objects. The Jonesean myth is Sellars’s positive reconstruction of mentalistic talk: mental states are not pre-given inner objects we somehow inspect, but theoretical entities whose semantic content is fixed by their inferential role — which means mentalistic vocabulary is parasitic on public language, not foundational for it. This single move — “the categories of inner episodes are modelled on the categories of intersubjectively available language” — is the historical hinge on which the inferentialist turn rotates.

For agent communication, EPM is the philosophical warrant for treating the wire as the semantic ground floor and the agent’s mind as a downstream theoretical posit. The standard worry about public-semantics ACLs is that they leave out “what the agent really meant”; Sellars’s answer is that “what the agent really meant” is itself a theoretical extrapolation from public discursive practice, not a pre-given inner episode the public practice approximates. The mentalistic ACL semantics that Sellars’s argument undermines is precisely the FIPA/Cohen–Levesque picture that Singh 1998 sets aside.

Key Ideas

The Myth of the Given: the foundationalist idea that knowledge rests on preconceptual, immediately-known sensory contents is incoherent. Anything that can justify a belief is already conceptually articulated; epistemic standing lives in the space of reasons.
Looks-talk is parasitic on is-talk: “X looks red to me” is not a more secure foundation than “X is red”; it is a hedge introduced after we have learned to deploy is-red, used when we want to undertake the commitment to a colour-impression without undertaking the commitment to the colour itself.
The Jonesean myth: a methodological fiction in which a community with only behavioural language develops mentalistic vocabulary by introducing thoughts (modelled on overt speech) and sensations (modelled on the perceptible properties of physical objects) as theoretical entities. The point: mentalistic talk is a theoretical posit, not a description of pre-given inner data.
The space of reasons: “In characterizing an episode or a state as that of knowing, we are not giving an empirical description of that episode or state; we are placing it in the logical space of reasons, of justifying and being able to justify what one says.” §36 — the most-quoted line in 20th-century epistemology.
Psychological nominalism: all awareness of universals, kinds, sorts, and resemblances is linguistic awareness — there is no preconceptual awareness of abstract entities.
Sapience over sentience: the distinction between concept-using creatures and others is participation in the game of reasons, not the having of qualia.

Connections

Conceptual Contribution

Claim: Knowledge cannot be grounded in preconceptual given sensory contents; epistemic standing requires conceptual articulation, which is inherently a public, language-involving achievement. Mentalistic vocabulary is a theoretical posit modelled on public discourse, not a description of pre-given inner data.
Mechanism: A dialectical demolition of sense-datum theory in §§1–7, a developmental account of looks-talk in §§10–20, and the Jonesean myth in §§48–63 in which mentalistic vocabulary is introduced into a behavioural community as a theory whose entities (thoughts, sensations) are modelled on already-public categories (overt speech, perceptible properties).
Concepts introduced/used: Myth of the Given, Space of Reasons, Psychological Nominalism, Sapience vs Sentience, Looking-Talk, Jonesean Myth, Theoretical Posit, Conceptual Articulation, Semantics-Without-Minds.
Stance: foundational philosophical paper.
Relates to: The historical hinge on which the entire inferentialist / Pittsburgh school turns. Brandom and MIE are the systematic development of the positive programme implicit in EPM’s negative demolition. The argument that mentalistic talk is parasitic on public language is the philosophical underwriting of Singh’s move from mentalistic to social-commitment semantics for ACLs, and of CBCL’s decision to ground meaning at the wire format rather than at the agent internals. The complementary moves in the same generation are Quine 1951 (against the analytic-synthetic distinction and for holism) and Wittgenstein 1953 (meaning as use).

Semantic Holism

Thesis that the meaning of a sentence/term depends on its inferential role within an entire web of beliefs and inferential commitments, not in isolation. Defended by Quine (Web of Belief, Confirmation Holism) and by Pittsburgh School inferentialists (Brandom).

In this vault

Two Dogmas of Empiricism - Quine

Two Dogmas of Empiricism

Reference: Quine, W. V. O. (1951). Two Dogmas of Empiricism. The Philosophical Review 60(1): 20–43. Reprinted in From a Logical Point of View (Harvard UP 1953). URL (PDF) · SEP entry on Quine

Summary

“Two Dogmas of Empiricism” is the paper that ended logical empiricism and made semantic holism respectable. Quine attacks two interlocking commitments of the Carnapian programme: (1) the analytic–synthetic distinction, the doctrine that some truths are true purely in virtue of meaning (analytic: all bachelors are unmarried) and others true in virtue of meaning plus how the world is (synthetic: snow is white); and (2) reductionism, the doctrine that every meaningful sentence is translatable into a statement about immediate experience. The two dogmas are mutually supporting — if either were good, the other would be needed to support it — and Quine shows that neither survives independent scrutiny.

The argument against the analytic–synthetic distinction works by demonstrating that every proposed definition of analyticity (in terms of synonymy, definition, semantic rules, or interchangeability salva veritate) either is circular or relies on a notion (cognitive synonymy, semantic rule) that is itself in need of the very explanation analyticity was supposed to provide. The argument against reductionism is that individual statements do not have their own range of experiential consequences — they face the tribunal of experience only as a body. The positive thesis that emerges is semantic holism: “Our statements about the external world face the tribunal of sense experience not individually but only as a corporate body” (§5). Coupled with Quine’s observation that no statement is immune to revision, this yields the famous web-of-belief picture: science is a fabric of beliefs in which the periphery is more responsive to experience and the interior (logic, mathematics, ontology) more conservative, but no part is constitutively immune.

For the inferentialist line, Quine plays an ambivalent role: he motivates inferentialism by demolishing the analytic–synthetic distinction, since one can no longer separate “the meaning of vixen” from “what we believe about vixens” — all the inferential connections in which vixen is enmeshed are partly constitutive of its meaning. But the same move threatens inferentialism, because if meaning is all the inferential connections then meaning is so holistic that no two speakers (or no speaker at two times) ever quite mean the same thing. This is the basis of Fodor and Lepore’s challenge: inferentialism inherits Quine’s holism, and Quine’s holism may be too much holism. For the ACL line, Quine matters because it implies that the meaning of propose, commit, retract in an ACL is constituted by the whole web of inferences in which those tokens are enmeshed — which is exactly why dialect contracts and protocol scaffolding matter: they fix the local web within which the wire-format performatives have determinate content.

Key Ideas

Two dogmas demolished: (1) the analytic–synthetic distinction is not defensible; (2) reductionism (every sentence has its own experiential cash value) is not defensible. They prop each other up; neither survives independently.
Circle of intensional notions: synonymy, analyticity, semantic rule, definition, cognitive equivalence — every attempt to define one in terms of the others is circular or empty.
Confirmation holism: scientific theories are tested as wholes against experience; the unit of empirical significance is the whole web of belief, not the individual sentence.
No statement is immune to revision: even logical and mathematical truths can be revised under sufficient empirical pressure (Quine cites quantum logic as illustration), and even peripheral observations can be saved by adjusting the interior of the web.
Web of belief: science is a fabric of beliefs with relations of mutual support; the periphery touches experience, the interior is more theoretically loaded, but the distinction is one of degree.
Pragmatic / empiricist reconstruction of analyticity: insofar as analytic has any use, it picks out sentences near the centre of the web, ones we are very reluctant to revise — a graded, pragmatic status rather than a sharp logical kind.

Connections

Conceptual Contribution

Claim: The analytic–synthetic distinction is undefendable, and theories meet the tribunal of experience as a whole, not statement-by-statement. Meaning is therefore not isolable from theory: the meaning of a term is partly constituted by the web of inferences in which it figures.
Mechanism: A six-section paper. §§1–4 walk through five candidate definitions of analyticity (definition, interchangeability salva veritate, semantic rules, etc.) and show each is either circular or empty. §5 attacks reductionism by showing that individual statements lack their own range of experiential consequences. §6 develops the positive picture: the web of belief / fabric of science, with peripheral statements more directly answerable to experience but no statement constitutively immune to revision.
Concepts introduced/used: Semantic Holism, Confirmation Holism, Web of Belief, Analytic-Synthetic Distinction, Quine-Duhem Thesis, Translation Manual (anticipating Word and Object).
Stance: foundational philosophical paper.
Relates to: Quine is the enabling condition for inferentialism: if the analytic–synthetic distinction held, then inferential role would only fix the analytic fragment of meaning and we would need reference / truth-conditions to do the rest. Quine collapses the distinction and lets inferentialism reach further. But Quine is also a threat: if meaning is the whole web, no two speakers mean the same thing, which is Fodor and Lepore’s pressure point against Brandom. The same dialectic applies to ACL semantics: meaning of a performative depends on the inferential web — which is why CBCL’s dialect contracts and the commitment-machine tradition matter — they fix the local web within which wire-format moves have determinate content. The complementary moves in the same period are Sellars 1956 (no Given) and Wittgenstein 1953 (meaning as use).

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

Philosophical Investigations - Wittgenstein

Philosophical Investigations

Reference: Wittgenstein, L. (1953). Philosophical Investigations. G. E. M. Anscombe (trans.). Blackwell, Oxford. Posthumous; Part I completed ca. 1945, Part II ca. 1949. URL (Anscombe translation PDF) · SEP entry · SEP: meaning

Summary

Philosophical Investigations (PI) is the grandparent of every twentieth-century approach to meaning that ties content to practice rather than to mental representation or correspondence — including the inferentialist, pragmatist, public-semantics, and commitment-based lines that this vault tracks. The book is non-systematic by design: §1–§133 set the stage by repudiating the Tractatus picture of language as a one-to-one mapping between names and objects; §§143–242 develop the rule-following considerations that culminate in the private-language argument (§243 ff.); the rest is a montage of “language-games” — concrete linguistic practices considered as wholes, in their natural settings — through which Wittgenstein dissolves rather than answers the standard puzzles of philosophy of mind and language.

Three Wittgensteinian theses are load-bearing for the rest of the vault. (1) Meaning is use (§43): “For a large class of cases — though not for all — in which we employ the word ‘meaning’ it can be defined thus: the meaning of a word is its use in the language.” Meaning is not a private mental object an inner Cartesian eye inspects, but a public regularity in linguistic practice. (2) Language-games are the unit of semantic analysis: a language-game is a complete, situated practice (giving orders, reporting events, asking questions, telling a joke, praying) within which words have determinate use. There is no language in general, only language-games. (3) The rule-following considerations and private-language argument: rules cannot determine their own application — there is no fact about how to “go on” in a series that is fixed independently of the practice of going on. Whether a person is following a rule correctly is settled by the public practice of the community, not by an inner state of intending-this-rule. A fortiori there can be no purely private language: meaning requires the corrective pressure of a community.

For agent communication, Wittgenstein is the ancestor in three respects. First, he supplies the philosophical permission to treat the wire — the publicly observable linguistic practice — as the semantic primary unit rather than as a thin trace of richer inner episodes. Second, the language-game concept directly anticipates the operational language-game tradition of Steels and the broader emergent-communication line. Third, the rule-following considerations are the philosophical complement to Lewis 1969 on convention: the question “what makes this regularity the rule the community follows?” is answered by the same mutual-expectation structure Lewis formalises and that Halpern–Moses 1990 reuse in distributed systems. The PI is also, importantly, the text Sellars and Brandom are explicitly working out the consequences of.

Key Ideas

Meaning is use (§43): the meaning of a word is its role in a public linguistic practice, not a mental object the speaker associates with the word.
Language-games: the unit of semantic analysis is not the isolated word, sentence, or proposition but the language-game — a complete situated linguistic practice (giving orders, reporting events, asking questions). There is no language in general; only language-games.
Family resemblance (§§65–67): concepts (like game) need not share a single essence; the items falling under a concept are connected by a network of overlapping similarities, like the resemblances among members of a family.
Rule-following considerations (§§143–242): rules do not determine their own application; what counts as “going on in the same way” is settled by the public practice of the community, not by an inner state of intending-the-rule.
Private-language argument (§243 ff.): a language whose terms refer to inherently private sensations, with no public criteria of application, is not a possible language. Meaning requires correction by a community.
Forms of life (Lebensformen): language-games are embedded in broader patterns of activity and shared natural history; meaning is ultimately answerable to these patterns rather than to abstract logical structure.
Philosophy as therapy: many traditional philosophical problems arise from misuse of language and dissolve when we attend to the actual language-games in which the relevant words have their home.

Connections

Conceptual Contribution

Claim: Linguistic meaning is constituted by use — the role of expressions in concrete, situated language-games sustained by a community — not by inner mental content, abstract logical structure, or correspondence to extra-linguistic facts. Rules do not determine their own application; the public practice of the community does.
Mechanism: A montage of detailed cases (the builder’s language-game §2, slabs and pillars §§19–20, the diary-keeper in §258) in which traditional philosophical pictures of meaning, reference, sensation, and rule-following are shown to misfire when applied to actual linguistic practice. The private-language argument (§243 ff.) blocks the move to inner ostensive definition; the rule-following considerations (§§143–242) block the move to rules that determine their own application.
Concepts introduced/used: Meaning As Use, Language Game, Form of Life, Family Resemblance, Rule-Following, Private Language Argument, Public Criterion, Aspect Perception, Philosophical Therapy.
Stance: foundational philosophical work / posthumous opus magnum.
Relates to: The grandparent of every meaning-as-use approach in the twentieth century — Sellars explicitly takes up the public-language-priority thesis, Quine generalises the rejection of pre-linguistic semantic facts, and Brandom and Articulating Reasons develop the systematic inferentialist account that the PI’s aphoristic style only gestures at. The language-game idea is the direct ancestor of Steels’ operational language-games and the broader emergent-communication tradition. The rule-following considerations complement Lewis 1969 on convention: where Lewis gives a game-theoretic answer to “what sustains this regularity?”, Wittgenstein gives a practice-theoretic answer to “what makes it a rule rather than a regularity?” — these two answers operate at the same conceptual layer.

Studies in the Way of Words

Reference: Grice, H. P. (1989). Studies in the Way of Words. Cambridge, MA: Harvard University Press. ISBN 0-674-85270-2. Source file: grice-1989-studies-way-of-words-excerpt.pdf (partial: “Logic and Conversation” and “Further Notes”, scanned from the 1989 edition; full book not openly available). Cited by Elephant 2000 - A Programming Language Based on Speech Acts (McCarthy 1989).

Summary

Grice’s collected essays - centred on the 1967 William James Lectures “Logic and Conversation” - are the other foundational pillar (alongside Austin and Searle) of contemporary pragmatics. The volume presents the Cooperative Principle and its four maxims (Quantity, Quality, Relation, Manner) as the engine driving conversational implicature: hearers reason from the assumption that speakers are cooperating to infer what is meant beyond what is literally said. The essays on utterer’s meaning and speaker intention build a reductive account of non-natural meaning in terms of nested intentions - the semantic basis for intention-based theories of communication used in mentalist ACL semantics (FIPA-ACL) and critiqued by commitment-based alternatives. McCarthy cites Grice in Elephant 2000 as one of the philosophical sources for treating machine utterances as meaningful speech acts.

Key Ideas

Cooperative Principle: make your contribution such as is required, at the stage at which it occurs, by the accepted purpose of the talk exchange.
Four maxims: Quantity (informativeness), Quality (truthfulness), Relation (relevance), Manner (perspicuity).
Conversational implicature: what is meant beyond what is said, derived by hearer’s reasoning about speaker adherence to (or flouting of) the maxims.
Conventional vs conversational implicature: some implicatures attach to specific words (“but”, “therefore”); most arise from cooperative reasoning.
Utterer’s meaning / non-natural meaning (meaning-NN): analysed via nested speaker-intentions that the hearer recognise the intention and respond accordingly.
Further Notes refines the theory: distinguishing what is said, what is conventionally implicated, and what is conversationally implicated.

Connections

Conceptual Contribution

Claim: Communication is driven by cooperation: hearers derive what a speaker means by assuming the speaker is observing the Cooperative Principle and its maxims, which explains implicature without complicating the semantics.
Mechanism: Cooperative Principle plus four maxims; what is said vs what is implicated; conventional vs conversational implicature; meaning-NN analysed as reflexive speaker-intention recognised by the hearer.
Concepts introduced/used: Cooperative Principle, Conversational Implicature, Maxims of Conversation, Utterer’s Meaning, Meaning-NN, Speaker Intention
Stance: foundational / pragmatics / intention-based semantics
Relates to: The intention-recognition account underlies the mentalistic feasibility/sincerity preconditions in FIPA-ACL cited by Agent Communication And Institutional Reality; the cooperative-principle framing appears implicitly whenever ACL designers assume benevolent agents, a target of the critique in ACL Rethinking Principles and Commitment-based Semantics.

Tags

#pragmatics #grice #implicature #philosophy-of-language #foundational

Minds Brains and Science

Minds, Brains and Science

Reference: Searle, J. R. (1984). Minds, Brains and Science (The 1984 Reith Lectures). Cambridge, MA: Harvard University Press. ISBN 0-674-57633-0. Source file: searle-1984-minds-brains-science.pdf. Cited by Elephant 2000 - A Programming Language Based on Speech Acts (McCarthy 1989).

Summary

Searle’s 1984 BBC Reith Lectures, lightly revised for print, compress his philosophy of mind into six accessible chapters: the mind-body problem, “Can Computers Think?”, cognitive science, the structure of action, prospects for the social sciences, and the freedom of the will. Chapter 2 contains the popular restatement of the Chinese Room Argument against strong AI: syntactic manipulation of symbols (what a program does) is neither sufficient for nor constitutive of semantics (what a mind has), so “appropriately programmed computer” cannot literally understand. Chapter 4 develops intentional action and prior intentions, and chapter 5 applies the same framework to collective/institutional phenomena - the seed of Searle’s later work on Institutional Reality. McCarthy cites this book in Elephant 2000 as the canonical target of his counter-position: programs can usefully be regarded as performing speech acts and having intentional states, if only in a deflationary “as-if” sense.

Key Ideas

Biological naturalism: mental phenomena are caused by and realised in brain processes; mind is neither reducible to nor separate from biology.
Strong vs weak AI: simulating a mind is not having one; syntax does not suffice for semantics (Chinese Room).
Intentionality and the background: intentional states presuppose a non-representational background of capacities and practices.
Structure of action: prior intention vs intention-in-action; causal self-referentiality of intention.
Social facts and collective intentionality: institutional reality rests on shared we-intentions (developed more fully later in Institutional Reality).

Connections

Conceptual Contribution

Claim: Minds are biological; programs running on machines lack intrinsic intentionality because syntactic symbol manipulation does not yield semantic content. Yet the same intentional vocabulary used for minds also grounds action theory and social reality.
Mechanism: Chinese Room thought experiment; distinction between intrinsic, derived, and as-if intentionality; action-theoretic analysis of intention-in-action; collective-intentionality sketch for social facts.
Concepts introduced/used: Biological Naturalism, Chinese Room Argument, Intrinsic Intentionality, Background, Collective Intentionality, Institutional Reality
Stance: anti-computationalist / philosophy-of-mind
Relates to: McCarthy’s Elephant 2000 - A Programming Language Based on Speech Acts explicitly rejects Searle’s conclusion and treats programs as speech-act performers; Searle’s action theory here is the philosophical ancestor of the mentalistic semantics used in FIPA-ACL and critiqued in Agent Communication And Institutional Reality and Commitment-based Semantics.

Tags

#philosophy-of-mind #searle #chinese-room #intentionality #speech-acts

Speech Acts - An Essay in the Philosophy of Language

Speech Acts: An Essay in the Philosophy of Language

Reference: John R. Searle (1969). Speech Acts: An Essay in the Philosophy of Language. Cambridge University Press. Source file: Searle 1969 - Speech Acts.pdf. URL

Summary

Searle’s foundational monograph gives speech-act theory its first systematic, philosophically defended treatment. Extending Austin’s How to Do Things with Words, it argues that the minimal unit of linguistic communication is neither the symbol nor the sentence but the production of the symbol in the performance of a speech act. Searle develops a constitutive-rule analysis of illocutionary acts, codifies the felicity conditions of paradigm acts (promising, referring, predicating, asserting), and uses the framework to attack the fact/value distinction, deriving “ought” from “is” via the institutional fact of promising.

The book introduces the now-canonical machinery that McCarthy’s Elephant 2000 - A Programming Language Based on Speech Acts imports as programming-language primitives: the force/content distinction F(p), propositional-content conditions, preparatory conditions, sincerity conditions, and essential conditions. It is also the direct ancestor of Foundations Of Illocutionary Logic, which formalises what Searle here develops discursively.

Key Ideas

Speech acts as the unit of meaning: producing a sentence under appropriate conditions is performing an illocutionary act; meaning reduces to a recursive theory of these acts.
Force vs. content F(p): every utterance factors into illocutionary force (assert, promise, request, …) and propositional content.
Constitutive rules: rules of the form “X counts as Y in context C” create institutional facts (promises, marriages) rather than merely regulating antecedent behaviour.
Felicity conditions for promising (canonical analysis): propositional-content, preparatory, sincerity, and essential conditions — the template every later ACL performative inherits.
Reference and predication as distinct speech acts, each with their own rules.
Institutional facts and the is/ought derivation via promising as a constitutive practice.

Connections

Elephant 2000 - A Programming Language Based on Speech Acts — McCarthy’s direct source for the speech-act vocabulary of Elephant
Foundations Of Illocutionary Logic — Searle & Vanderveken 1985, formalises the present book
Speech Act Theory
Speech Acts
Performatives
Illocutionary Force
Sincerity Conditions
Preparatory Conditions
Agent Communication And Institutional Reality
KQML
FIPA-ACL
Agent Communication Languages
Commitment-based Semantics

Conceptual Contribution

Claim: Linguistic communication is irreducibly act-theoretic: the minimal unit of meaning is the illocutionary act, analysable by constitutive rules and felicity conditions, and this analysis extends to reference, predication, and the generation of institutional facts.
Mechanism: Case studies of promising, referring, and asserting yield a recursive schema F(p) with four condition-types (propositional-content / preparatory / sincerity / essential). The schema is then redeployed to distinguish regulative from constitutive rules and to dissolve the classical is/ought problem by showing that uttering “I promise” institutionally constitutes an obligation.
Concepts introduced/used: Performatives, Illocutionary Force, Sincerity Conditions, Preparatory Conditions, Speech Act Theory, Institutional Reality, Commitment-based Semantics
Stance: foundational / philosophical
Relates to: Imported wholesale by Elephant 2000 - A Programming Language Based on Speech Acts as the philosophical basis for speech-act I/O; formalised by Foundations Of Illocutionary Logic; re-examined for multi-agent systems in Agent Communication And Institutional Reality and operationalised in KQML / FIPA-ACL performative sets. McCarthy explicitly departs from Searle by adopting a design stance on these primitives — see Abstract Performative.

Tags

How to Do Things with Words

Reference: Austin, J. L. (1962). How to Do Things with Words. The William James Lectures delivered at Harvard University in 1955. Oxford: Clarendon Press (ed. J. O. Urmson). Source file: austin-1962-how-to-do-things-with-words.pdf. Cited by Elephant 2000 - A Programming Language Based on Speech Acts (McCarthy 1989).

Summary

Austin’s posthumously edited William James Lectures are the founding text of speech-act theory. Austin begins by isolating a class of utterances - “performatives” (e.g. “I promise”, “I do”, “I name this ship”) - that do not describe or report but instead perform an action, and cannot be evaluated as true or false but only as happy or unhappy (felicitous or infelicitous). Through twelve lectures he progressively dissolves the performative/constative distinction in favour of a general theory in which every utterance performs a locutionary, illocutionary, and perlocutionary act. The taxonomy of illocutionary force (verdictives, exercitives, commissives, behabitives, expositives) directly anticipates Searle/Vanderveken’s Foundations Of Illocutionary Logic and the performative vocabulary of KQML and FIPA-ACL.

Key Ideas

Performative utterance: saying is doing. “I promise” is not a report of a promise - it is the promise.
Felicity conditions: instead of truth conditions, performatives succeed or fail by satisfying procedural, sincerity, and uptake conditions.
Locution / illocution / perlocution: three layers of every speech act - what is said, what is done in saying it, and what is achieved by saying it.
Five illocutionary classes (verdictives, exercitives, commissives, behabitives, expositives) - taxonomy later refined by Searle into five primitives.
Dissolution of the performative/constative boundary: assertion itself turns out to be a species of illocutionary act.

Connections

Conceptual Contribution

Claim: Many utterances are not descriptions that can be true or false but actions that are performed in the saying; and on closer inspection the descriptive/performative divide collapses, so every utterance is a layered act with illocutionary force.
Mechanism: Contrast between constative and performative utterances; introduction of felicity conditions (A.1-A.2, B.1-B.2, Gamma.1-Gamma.2 misfires and abuses); the tri-layer locution/illocution/perlocution analysis; provisional five-way classification of illocutionary verbs.
Concepts introduced/used: Performatives, Illocutionary Force, Felicity Conditions, Locutionary Act, Perlocutionary Act, Speech Act Theory
Stance: foundational / ordinary-language-philosophy
Relates to: Provides the raw speech-act ontology that Searle formalises in Speech Acts and that McCarthy imports in Elephant 2000 - A Programming Language Based on Speech Acts; the felicity-condition apparatus recurs under “feasibility” and “sincerity” preconditions in FIPA-ACL semantics and in Commitment-based Semantics.

Tags

#speech-acts #philosophy-of-language #foundational #austin #performatives

The Society of Mind

Reference: Marvin Minsky (1986). Simon & Schuster (Touchstone). ISBN 0-671-65713-5. Source file: minsky-society-of-mind.pdf. URL

Summary

Minsky’s landmark synthesis: mind is built from many small agents each of which by itself can only do very simple things, yet collectively — through the right kinds of organisation — give rise to intelligence. Thirty short chapters (each a few pages of essays numbered by subsection) develop a cognitive architecture in which no single agent is conscious, no single agent thinks, and no single agent understands — understanding is always a property of a society of agents working together.

The book ranges across agent theory (agents and agencies, hierarchies and heterarchies), memory (K-lines as activatable sets of agents that were co-active when something was learned), introspection (B-brains watching A-brains watching the world), language (polynemes, isonomes, micronemes, pronomes as classes of inter-agent signals), frames (trans-frames for actions, scripts for scenes), reasoning (chains, uniframes, negation), emotion and development (attachment learning, Papert’s principle), individuality (no unified self — an illusion produced by conflicting agencies), and consciousness (a coarse-grained access to the immediately prior mental state). Across all of it the architectural thesis is the same: agencies, not agents, do the work; and the agencies are themselves agencies all the way down.

As a cognitive-architecture proposal the book is a precise anti-unitarian manifesto — against the idea that there is a single central “thinker”, a single logical reasoner, or a single goal-pursuing executive. It is also the philosophical wellspring of modern multi-agent AI: Shoham’s Agent-Oriented Programming, Wooldridge & Jennings’ agent theory, the BDI tradition, and today’s LLM Agents frameworks (MetaGPT, CAMEL, AutoGen, AGENTS) all descend from — and often explicitly cite — this picture.

Key Ideas

Agents and agencies: the mind is a society; each agent is a specialist that knows little on its own; intelligence is organisational
Parts and wholes: a mind has no single “centre”; every whole is made of parts that are themselves wholes of smaller parts
Hierarchies and heterarchies: not pure trees — agencies form overlapping networks with mutual reciprocity
K-lines: Minsky’s theory of memory — a memory is a K-line that, when activated, re-arouses the set of agents whose joint activity earlier constituted the experience
B-brains and levels of introspection: a brain that watches another brain (and so on); the basis of self-knowledge, but also of systematic error
Frames and trans-frames: structured templates for objects and actions; trans-frames carry the origin/trajectory/destination pattern that underwrites verbs and planning
Polynemes / isonomes / micronemes / pronomes: categories of inter-agent signals — the ‘language’ in which agencies speak to each other
Papert’s Principle: genuine mental growth depends less on acquiring new skills than on acquiring better managerial agents that coordinate old ones
Uniframes and the Exception Principle: concepts are unified by exceptions-as-features, not by defining necessary-and-sufficient conditions
The self as society: personal identity is the persistent organisation of one’s agencies, not a unitary soul or homunculus
No sharp line between reasoning and perception: they are the same agency-activation process with different inputs

Connections

Ascribing Mental Qualities to Machines — McCarthy’s companion stance on design-stance mentalism
Intelligent Agents Theory and Practice — Wooldridge & Jennings’ weak/strong agency taxonomy
Agent-Oriented Programming — Shoham’s first-class “agent” abstraction descends from Minsky’s
Multi-Agent Systems
Multiagent Systems Sycara
BDI
Mental State
The Knowledge Level — Newell’s complementary stratification
Computational Boundary of a Self — Levin’s scale-free generalisation of the individual-as-society idea
Theory of Self-Reproducing Automata — the complication-threshold thesis is a direct ancestor
Self-Adaptive Systems
Agents Framework - Zhou et al
MetaGPT Meta Programming for Multi-Agent Collaboration
CAMEL Communicative Agents for Mind Exploration of LLM Society
AutoGen - Multi-Agent Conversation Framework
Multi-Agent Collaboration in AI - Wasif Tunkel
The Rise and Potential of LLM-Based Agents
Why Do Multi-Agent LLM Systems Fail
Language Games for Autonomous Robots
Myconet Fungi Inspired Superpeer Overlay
Ethical Governor
Metacognitive Loop
Ensuring Trustworthy and Ethical Behaviour in Intelligent Logical Agents
Subsumption Architecture
Semantic Information Processing
Common Sense Reasoning

Conceptual Contribution

Claim: Minds — human or artificial — are built from many simple specialist agents whose organised interactions produce intelligence. There is no single locus of thought, understanding, or selfhood; all mental phenomena are agency-level properties that dissolve if you look for them at the single-agent level.
Mechanism: Thirty small chapters each arguing from introspective examples, developmental psychology, and computational thought-experiments to commit to a specific architectural hypothesis — K-lines for memory, trans-frames for action, pronomes/polynemes for inter-agent signalling, B-brains for introspection, Papert’s principle for growth, the exception principle for concepts. No single chapter is decisive; the book’s force is cumulative.
Concepts introduced/used: Society of Mind, Agents (Minsky), Agencies, K-Lines, Trans-Frames, Pronomes, Polynemes, Isonomes, Micronemes, B-brains, Papert’s Principle, Uniframes, Difference-Engines, Frames (AI), Exception Principle, Investment Principle, Society-of-More
Stance: foundational / essay
Relates to: Minsky’s book is the direct ancestor of the Multi-Agent Systems paradigm. Agent-Oriented Programming, Intelligent Agents Theory and Practice, Multiagent Systems Sycara all inherit the agent-as-specialist framing. The modern LLM-agent revival (MetaGPT Meta Programming for Multi-Agent Collaboration, CAMEL Communicative Agents for Mind Exploration of LLM Society — note the name! — AutoGen - Multi-Agent Conversation Framework, The Rise and Potential of LLM-Based Agents) explicitly returns to the Society-of-Mind idiom: competence emerges from societies of small specialists talking to each other, not from a single monolithic model. B-brains prefigure the runtime self-oversight loop of Ensuring Trustworthy and Ethical Behaviour in Intelligent Logical Agents and the Metacognitive Loop / Ethical Governor. The anti-unitarian account of the self sits beside Computational Boundary of a Self (Levin) and the scale-free-cognition programme. Read alongside The Knowledge Level: Newell describes what such a system means at the agent level; Minsky gives a candidate how.

The Knowledge Level

Reference: Allen Newell (1982). “The Knowledge Level.” Artificial Intelligence 18(1): 87-127. (AAAI Presidential Address, Stanford, 19 Aug 1980; also in AI Magazine 2(2), 1981.) URL

Summary

Newell’s AAAI-80 presidential address proposes that above the symbol level (data structures manipulated by programs) there exists a distinct knowledge level whose medium is knowledge and whose laws are rationality. At the knowledge level an agent is characterised by what it knows and what goals it has; its behaviour is predicted by the principle of rationality — “if an agent knows that one of its actions will lead to a goal, it will select that action” — without commitment to any particular representation or processing mechanism.

The paper motivates the proposal by diagnosing three tensions in early-1980s AI: the mystification of “representation,” the residue of the 1960s-70s theorem-proving controversy (Planner/Microplanner/Conniver’s “uniform procedures will not work” reaction against resolution), and the diversity of answers in the SIGART Special Issue on Knowledge Representation (Brachman and Smith’s survey showing no consensus on quantification, quotation, self-description, or evaluation). Newell’s resolution: treat knowledge as a competence-level notion analogous to physicists’ treatment of temperature — a level with its own laws, reduced to but not replaced by the symbol level. Representations are then understood as symbol-level implementations of knowledge, and we gain a principled way to talk about what an AI system knows without confusing it with how that knowledge is stored.

The Knowledge Level is foundational for agent-oriented programming (Shoham’s “mental state” framing), for the BDI tradition, for KQML’s and FIPA’s claim that ACL semantics should be defined at the level of beliefs/intentions rather than byte-strings, and indirectly for McCarthy’s Elephant 2000, whose speech-act semantics presupposes that one can talk coherently about what a program knows and is committed to, independently of implementation.

Key Ideas

Computer systems are describable at multiple levels (device, circuit, logic, register-transfer, program/symbol); the knowledge level sits above the symbol level.
Medium of the knowledge level: knowledge (distinct from the data structures that represent it).
Law of behaviour at the knowledge level: the principle of rationality — actions selected to achieve goals given what is known.
The knowledge level is a competence-level account: it predicts behaviour without specifying mechanism, analogously to economic rationality.
Representation is the symbol-level realisation of knowledge; mystifying representation conflates the levels.
Diagnostic of the theorem-proving backlash: “uniform procedures will not work” was a symbol-level reaction to a knowledge-level question.

Connections

Agent-Oriented Programming — Shoham explicitly situates AOP at the knowledge level; mental states are Newell-level predicates over agents.
Elephant 2000 - A Programming Language Based on Speech Acts — Elephant commits to knowledge-level program variables (propositions, commitments, past speech acts), making knowledge-level description the native semantics of programs.
Ascribing Mental Qualities to Machines — McCarthy’s ascriptivism is the philosophical cousin of Newell’s levels argument.
Knowledge Representation
Agent Communication Languages — ACL semantics in the KQML/FIPA tradition are knowledge-level (beliefs/intentions) rather than symbol-level (bit patterns).
KIF — intended as a lingua franca at the symbol level that preserves knowledge-level content across heterogeneous systems.
Common Sense Reasoning

Conceptual Contribution

Claim: AI systems have a level of description above the symbol level — the knowledge level — whose medium is knowledge and whose law is rationality; this level is reducible to but not replaceable by the symbol level, and recognising it clarifies decades of representation debates.
Mechanism: Levels-of-description methodology imported from computer architecture; principle of rationality as the behaviour law; knowledge characterised competence-theoretically (what follows from what an agent knows and wants, not how); representations reconceived as symbol-level implementations of knowledge-level content; diagnostic application to the theorem-proving controversy and the SIGART Special Issue.
Concepts introduced/used: Knowledge Level, Symbol Level, Principle of Rationality, Competence vs Performance, Knowledge Representation, Levels of Description.
Stance: foundational
Relates to: The conceptual ground for agent-oriented and BDI programming; provides the “what an agent knows” vocabulary that KQML, Agent Communication Languages, and Elephant 2000 - A Programming Language Based on Speech Acts rely on; complements McCarthy’s ascriptivist argument in Ascribing Mental Qualities to Machines.

Reflexion Language Agents with Verbal Reinforcement Learning

Reflexion: Language Agents with Verbal Reinforcement Learning

Reference: Noah Shinn, Federico Cassano, Edward Berman, Ashwin Gopinath, Karthik Narasimhan, Shunyu Yao (2023). NeurIPS 2023 (Northeastern / MIT / Princeton). arXiv:2303.11366. Source file: reflexion-2303.11366.pdf. URL

Summary

Reflexion reinforces language agents not by updating weights but by verbal feedback: after each episode the agent converts scalar or binary success signals into a natural-language self-critique and stores that critique in an episodic memory buffer that conditions the next attempt. This acts as a semantic gradient, letting the agent learn from trial-and-error in a handful of episodes without fine-tuning. The framework factors an agent into three LLM-instantiated modules: an Actor (generates text and actions, typically a ReAct agent or CoT reasoner), an Evaluator (scores the trajectory), and a Self-Reflection model (produces the verbal feedback written to memory).

On ALFWorld (decision-making) Reflexion completes 130/134 tasks vs ~100 for ReAct alone (+22%); on HotpotQA reasoning it adds ~20%; on the HumanEval coding benchmark it reaches 91% pass@1, surpassing GPT-4’s 80%. The paper also releases LeetcodeHardGym. Reflexion is the canonical reference for self-reflective metacognitive loops in LLM agents.

Key Ideas

Verbal reinforcement: convert sparse scalar/binary rewards into natural-language lessons
Three-module architecture: Actor / Evaluator / Self-Reflection, all LLMs
Short-term memory = trajectory history; long-term memory = accumulated self-reflections (bounded, e.g. last 3)
No gradient updates: policy changes via in-context memory, not weight updates
Self-reflection helps identify both mistaken actions (hallucination) and mistaken plans (inefficient planning)
Works on top of ReAct, CoT, or other actor policies; orthogonal to prompting style
State-of-the-art results on HumanEval, ALFWorld, HotpotQA with only a handful of trials

Connections

Conceptual Contribution

Claim: Language agents can be reinforced effectively without weight updates by converting sparse environmental feedback into verbal self-critiques that persist in episodic memory and steer subsequent behaviour — an emergent property of sufficiently capable LLMs that is far cheaper than RL fine-tuning.
Mechanism: After trajectory τ_t, the Evaluator M_e computes a reward r_t; the Self-Reflection model M_sr takes (τ_t, r_t) and produces a natural-language lesson sr_t appended to a memory buffer mem (|mem| ≤ Ω). The Actor M_a’s policy π_θ is parameterised by (M_a, mem), so on trial t+1 the in-context memory steers action selection. Iteration until Evaluator passes or max trials reached.
Concepts introduced/used: Verbal reinforcement learning, self-reflection, episodic memory for LLM agents, Actor-Evaluator-Self-Reflection decomposition, credit assignment via LLM, LeetcodeHardGym benchmark, in-context policy iteration.
Stance: empirical / methods — framework with ablations across three task families.
Relates to: Stacks on top of ReAct Synergizing Reasoning and Acting in Language Models (Reflexion’s default Actor is ReAct) and is the prototypical Metacognitive Loop for LLM agents. Makes memory-augmented agents a practical design pattern, related to the memory streams of Generative Agents. A core reference in The Rise and Potential of LLM-Based Agents and Agents Framework - Zhou et al, and an instance of the self-improvement / self-reflection family in MAST Taxonomy. Part of the broader family of LLM Agents that learn in-context rather than via gradient descent.

Tags

ReAct Synergizing Reasoning and Acting in Language Models

ReAct: Synergizing Reasoning and Acting in Language Models

Reference: Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, Yuan Cao (2023). ICLR 2023 (Princeton / Google Brain). arXiv:2210.03629. Source file: react-2210.03629.pdf. URL

Summary

ReAct is a prompting paradigm that interleaves verbal reasoning traces (thoughts) with task-specific actions in a single LLM generation, letting the model plan, update its plan with observations from the environment, and query external sources. Unlike chain-of-thought (reasoning only) or action-only agents (e.g. WebGPT-style), ReAct alternates Thought -> Action -> Observation steps, so the model grounds its reasoning in retrieved evidence and uses its reasoning to decide what to act on next.

Evaluated on HotPotQA, Fever (Wikipedia API with search/lookup/finish actions), ALFWorld (text household tasks), and WebShop. On knowledge tasks ReAct outperforms action-only prompting and, combined with chain-of-thought self-consistency, beats CoT alone by reducing hallucination. On decision-making tasks ReAct beats imitation-learning and RL baselines by absolute 34% and 10% respectively, using only one or two in-context examples. The paper is the seminal reference for tool-using LLM agents and the thought/act/observe loop now ubiquitous in LLM agent frameworks.

Key Ideas

Interleave reasoning (thoughts) and acting (tool/API calls) in one LLM trajectory
Augment the action space A with a free-form language space L of “thoughts” that do not affect the environment but update the context
External Wikipedia API (search, lookup, finish) as a minimal tool interface for QA
Back-off combination with CoT self-consistency: use ReAct when it finishes, otherwise fall back to CoT-SC, or vice versa
Human-interpretable, inspectable, and edit-able agent trajectories (“thought editing”)
Few-shot prompts with 1-6 exemplars suffice; fine-tuning on 3k trajectories further boosts small models

Connections

Conceptual Contribution

Claim: Reasoning and acting are synergistic rather than separate capabilities; interleaving them in a single LLM generation produces agents that are more grounded, less hallucination-prone, and more robust than pure reasoning (CoT) or pure acting (WebGPT-style) baselines.
Mechanism: Extend the agent’s action space to A’ = A ∪ L where L is the free-form language of thoughts. Prompt the LLM with few-shot thought/action/observation exemplars. The model decides when to think and when to act; observations from the environment (API results, game state) re-enter the context and condition subsequent thoughts.
Concepts introduced/used: Thought-Act-Observation loop, tool-use prompting, interleaved reasoning/acting, grounded reasoning, hallucination reduction via external knowledge, few-shot agent prompting, thought editing, ReAct + CoT-SC back-off.
Stance: empirical / methods — prompting-level intervention with extensive benchmarks.
Relates to: Direct successor to Chain-of-Thought Prompting — CoT without actions is shown to hallucinate (14% vs ReAct’s 6%). Makes tool use a first-class LLM behaviour, complementary to Toolformer’s self-taught API-call fine-tuning. Foundational for LLM Agents and a key building block in Agents Framework - Zhou et al. The thought/act/observe skeleton is reused by nearly all subsequent agent papers, including Reflexion Language Agents with Verbal Reinforcement Learning (which uses ReAct as its default Actor).

Tags

The Semantic Web

Reference

Berners-Lee, Tim; Hendler, James; & Lassila, Ora (2001). “The Semantic Web.” Scientific American 284(5): 34–43, May 17 2001.
PDF: jmvidal.cse.sc.edu/library/berners-lee01a.pdf
Also: scientificamerican.com/article/the-semantic-web
Lassila’s site: lassila.org/publications/2001/SciAm.html
Local: semanticweb2001.pdf

Summary

Berners-Lee, Hendler, and Lassila sketch an extension of the World Wide Web in which content carries machine-processable meaning, enabling software agents to perform non-trivial tasks on behalf of users. The article opens with the now-famous Pete-and-Lucy vignette: Lucy’s agent coordinates medical appointments, cross-references insurance providers, negotiates schedules with Pete’s agent, and replans when a preferred plan is rejected. The authors stress that this does not require HAL-level AI; it requires that web pages embed structured semantics that off-the-shelf tools can author and that agents can consume.

The vision rests on three interlocking commitments. First, meaning is expressed through structured data formats — XML for syntax, RDF for triples (subject–predicate–object with URIs), and ontologies that give classes, properties, and inference rules a shared interpretation. Second, the Web’s decentralisation is preserved: unlike traditional knowledge-representation systems that require a single central vocabulary, the Semantic Web accepts paradoxes and unanswerable questions as the price of scale, and lets ontologies be published, linked, and partially reused. Third, agents are the consumers: they roam from page to page, chain inferences across ontologies, evaluate trust via digital signatures and proofs, and negotiate on behalf of human users. The article walks through examples of rule-based inference, ontology alignment (e.g., reconciling “zip code” across sites), and the architecture of trust (“Oh, yeah?” buttons) that lets an agent verify claims by following proofs.

Throughout, the tone is programmatic. The authors concede that knowledge representation has existed since long before the Web and is “in a state comparable to that of hypertext before the advent of the Web” — useful demos but no global connective tissue. The Semantic Web’s contribution is not new KR theory but linking KR into a single global system, exactly as hypertext was the connective tissue for documents. The payoff is machine-to-machine data integration, delegated tasks, and a qualitative shift in what individual users and organisations can accomplish through agents.

Key Ideas

Machine-processable meaning on the Web: structured data with URI-identified terms, not just rendered documents.
Layered stack: URIs → XML → RDF (triples) → Ontologies (OWL-like) → Logic/Rules → Proof → Trust.
Decentralised knowledge representation: no central ontology; partial agreement, mapping between vocabularies.
Agents as consumers: the reason the Semantic Web matters is that software agents can act on the structured content, including negotiating, scheduling, verifying.
Ontologies provide shared classes, properties, and inference rules; critical for cross-site data integration.
Trust via proofs and digital signatures: an agent should be able to demand the derivation of a claim and check it.
Pete-and-Lucy scenario as the canonical multi-agent, multi-ontology, real-world task.
Hypertext analogy: KR is where hypertext was pre-Web — good ideas, no global connective layer; the Semantic Web is that layer.

Connections

Semantic Web — the cluster topic this paper names.
Ontologies — ontologies are the load-bearing layer of the Semantic Web stack.
Handbook On Ontologies — systematic treatment of the ontology engineering the paper demands.
Ontolingua Portable Ontology Specifications — prior art on shareable ontology specifications that feeds into the Semantic Web plan.
Toward Principles for the Design of Ontologies Used for Knowledge Sharing — Gruber’s principles underlie the Semantic Web’s ontology layer.
A Common Ontology Of ACLs, ACL Design Principles — the ACL literature provides the agent-to-agent communication layer that Pete’s and Lucy’s agents would need.
Multi-Agent Systems, Intelligent Agents Theory and Practice, On Agent-Based Software Engineering — the agent side of the vision; Jennings’s “knowledge-level interaction” is the social counterpart to the Semantic Web’s data-level interoperability.
A Framework for Representing Knowledge — frames, slots, defaults prefigure RDF/OWL class-property structure.
Knowledge Representation — the historical discipline whose ideas the Semantic Web proposes to “link into a single global system”.
Abstract Agent Interfaces — interface-level agreement aligning with ontology-level agreement.

Conceptual Contribution

On Agent-Based Software Engineering

Reference

Jennings, Nicholas R. (2000). “On agent-based software engineering.” Artificial Intelligence 117(2): 277–296. (Based on the Computers and Thought Award lecture, IJCAI-99 Stockholm.)
PDF: jmvidal.cse.sc.edu/library/abse.pdf
Also: faculty.sites.iastate.edu/tesfatsi/archive/tesfatsi/jennings.pdf
ePrints Soton: eprints.soton.ac.uk/253741/
Local: jennings2000_agent_based_se.pdf

Summary

Jennings argues that agent-oriented techniques are not a mere rebranding of object-orientation or distributed computing but a genuinely new software engineering paradigm, particularly well-suited to complex, distributed, real-world systems. Contemporary software engineering paradigms (OO, component-ware, design patterns, software architectures) fall short in two ways when building such systems: (i) interactions between computational entities are defined too rigidly at design time, and (ii) there are insufficient mechanisms for representing a system’s organisational structure. He advances two theses: the Adequacy Hypothesis — agent-oriented approaches significantly improve our ability to model, design, and build complex distributed software — and the Establishment Hypothesis — agent orientation will succeed as a mainstream SE paradigm.

The paper offers a careful definition: an agent is an encapsulated computer system situated in some environment and capable of flexible autonomous action to meet its design objectives. Agents are (i) identifiable problem-solvers with well-defined boundaries, (ii) situated, (iii) purposive, (iv) autonomous (controlling both state and behaviour — this is what distinguishes them from objects, which must obey any public method call), and (v) flexible (reactive and proactive). Crucially, real problems require multi-agent solutions; the essential concepts of agent-based computing are agents, high-level (knowledge-level) interactions, and explicit organisational relationships. The canonical diagram shows agents, interaction links, organisational groupings, and spheres of visibility and influence over a shared environment.

Interactions are conceptualised at the knowledge level (Newell): who should do what, when, on whose behalf — not at the syntactic level of method invocation. Agents decide at run time how to interact, including engaging in interactions unforeseen at design time. Organisational relationships (peer, team, manager/subordinate) shape behaviour and must be represented explicitly because they evolve during execution. Jennings then argues the case for agent-based software engineering, examines its drawbacks (hard to predict, hard to verify, concurrency pitfalls, immature methodologies), and advocates modelling at the social level as the promising remedy.

Key Ideas

Agents as the right abstraction for complex distributed systems: encapsulated, situated, autonomous, flexible.
Autonomy distinguishes agents from objects: objects must execute any invoked public method; agents choose whether to respond.
Interactions at the knowledge level: goal-level, run-time, negotiated — not hard-wired at design time.
Explicit organisational structure: teams, roles, authority relations must be first-class, and must be dynamic.
The canonical view: agents + high-level interactions + organisational relationships + shared environment.
Adequacy and Establishment Hypotheses: agent-orientation is both appropriate and likely to become mainstream.
Social level modelling: beyond the knowledge level, systems should be analysed in terms of roles, dependencies, and collective behaviour.
Drawbacks acknowledged: emergent behaviour, verification difficulty, lack of mature tooling, overhead for simple problems.

Connections

Multi-Agent Systems — this paper is one of the foundational manifestos for viewing SE through the MAS lens.
Intelligent Agents Theory and Practice — Wooldridge & Jennings’s companion treatment of the agent abstraction.
Agent-Oriented Programming — Shoham’s earlier proposal to shift from objects to agents; Jennings provides the SE-level case.
Multiagent Systems Sycara — complementary survey of MAS as a field.
Agent Architecture, Abstract Agent Interfaces — concrete architectural instantiations of Jennings’s abstraction.
A Scalable Communication Protocol for Networks of LLMs — modern echo of the “knowledge-level interaction, organisational structure” agenda.
ACL Design Principles, ACL Layering, A Common Ontology Of ACLs — the communication machinery that knowledge-level interaction presupposes.
Agent Communication And Institutional Reality — institutional/organisational framing extends Jennings’s call for explicit organisational relationships.
Contrast with Actor Model — actors encapsulate state but not autonomy of response.
Contrast with Intelligence Without Representation — Jennings is comfortable with knowledge-level abstractions Brooks is sceptical of.

Conceptual Contribution

Connector (Reo)

In Reo, a channel with typed source/sink endpoints whose behaviour is fixed by its channel type — synchronous, asynchronous, lossy, FIFO-N, filter, drain, replicate, etc. Channels compose by node-sharing into composite connectors whose behaviour is the synchronous product of their constituents’ Constraint Automata. The connector is the unit of coordination logic; components are abstracted as opaque endpoints.

In this vault

Channel-based Coordination

Coordination organised around explicit, programmable channels with typed endpoints and well-defined behaviour, rather than around messages, tuples, or shared variables. The defining stance of Reo (Arbab 2004): the channel is the unit of coordination logic, components are abstracted as opaque endpoints, and the coordination network is exogenous to the components being coordinated. Distinct from message-passing concurrency (CSP, Pi-Calculus) where channels are implicit synchronisation devices, and from tuple-space coordination (Linda) where the medium is the data store.

In this vault

Reo

Arbab’s (2004) channel-based Coordination Language: the primitive abstraction is a programmable channel with typed source/sink endpoints (synchronous, lossy, FIFO, filter, drain, replicate, …). Channels compose by node-sharing into composite connectors. Coordination logic lives exogenously in the connector network, separated from the components being coordinated. Compositional constraint-automata semantics (Baier et al. 2006). The algebraic counterpoint to Linda’s tuple-space approach.

In this vault

Locality (KLAIM)

In KLAIM, a locality is a named site where tuples reside and operations execute; the four Linda primitives carry a locality argument (out(t)@l etc.). An allocation environment maps logical locality names (used by agents) to physical sites (used by the runtime). Mobile agents migrate by eval(P)@l. Localities make administrative-domain structure first-class and are the units the μKLAIM type system constrains for access control.

In this vault

KLAIM

De Nicola, Ferrari & Pugliese’s (1998) Kernel Language for Agents Interaction and Mobility — a process calculus combining Linda’s tuple-space coordination with named localities and mobile eval for code migration. The companion type system μKLAIM statically enforces locality-access policies, giving a static-typing analogue of Capability Security for distributed mobile agents. The formal counterpart of mobile-agent platforms like Telescript and Agent Tcl.

In this vault

Coordination Language

A language designed specifically to express the coordination (synchronisation, communication, composition) of concurrent activities, distinct from any computation language that would express the activities’ internal logic. The framing is Gelernter’s: a parallel/distributed program = computation + coordination. Examples: Linda (1985), KLAIM (1998), Reo (2004), Manifold, GAMMA, Orc. Coordination languages are typically embedded — combined with a host computation language — and emphasise separation of concerns between what is computed and how concurrent computations interact.

In this vault

Tuple Spaces

Linda-style associative shared memories where processes coordinate by inserting, reading, and removing typed tuples via pattern matching, decoupling producers and consumers in space and time.

In this vault

Linda (coordination)

Gelernter’s (1985) coordination language built around a shared content-addressable tuple space accessed through four operations: out (write), in (consume on associative match), rd (read on match), eval (turn a tuple into a live computation). Decouples senders and receivers in space, time, destination, and form. The canonical example of separation of computation and coordination. Direct ancestor of JavaSpaces, TSpaces, KLAIM, and stigmergic-coordination frameworks.

In this vault

Generative Communication in Linda

Reference: Gelernter, D. (1985). Generative Communication in Linda. ACM Transactions on Programming Languages and Systems (TOPLAS), 7(1), pp. 80–112. (Companion: Carriero, N. & Gelernter, D. (1989). Linda in Context. Communications of the ACM 32(4), pp. 444–458.) DOI · Open access PDF (UCSD)

Summary

Gelernter introduces Linda, a coordination model for parallel and distributed programming organised around tuple spaces rather than message passing. A tuple space is a logically shared, content-addressable bag of tuples; processes communicate by writing tuples into the space (out), reading them with associative pattern matching (rd, in), and creating new processes through tuple-space operations (eval). The four operations — out (write), in (consume on match), rd (read on match without consuming), and eval (turn a tuple into a live computation) — together comprise the entire coordination language. Linda is generative in that produced tuples have an existence independent of the producer: once out is invoked, the tuple lives in the space and can be matched by any process at any time. This decouples senders from receivers in space, time, destination, and form — the four “dimensions of decoupling” Gelernter argues are essential for scalable parallel programming. The model is embedded: Linda is a coordination language designed to be combined with any host computation language (the original implementations were C-Linda and Fortran-Linda). The headline architectural claim is the separation of computation and coordination: a parallel program is a computation (algorithmic logic) plus a coordination (how concurrent activities synchronise and communicate); Linda provides the coordination layer in a way that is largely orthogonal to the host language. Linda directly inspired JavaSpaces (1998), TSpaces (1999), and the Klaim mobile-agent extension; it is the conceptual root of a substantial sub-tradition of coordination-language research that includes Reo (Arbab 2004) and Klaim (De Nicola, Ferrari & Pugliese 1998), and supplies one of the standard answers to “how do agents in a multi-agent system communicate without point-to-point addressing?”

Key Ideas

Tuple space as the universal medium: a logically shared, content-addressable bag of tuples; processes communicate exclusively through out / in / rd / eval on this single store.
Four operations:
- out(t) — write tuple t to the space (non-blocking).
- in(template) — atomically consume a tuple matching template (blocks until one exists).
- rd(template) — read but do not consume a matching tuple (blocks until one exists).
- eval(t) — like out, but each non-actual field is evaluated by a fresh concurrent process; producing a live, in-tuple-space computation.
Associative pattern matching: a template is a tuple containing actual values and typed wildcards; a tuple matches a template iff the structural shapes agree, the actual values are equal, and the wildcards bind to fields of the matching type.
Four dimensions of decoupling: Linda decouples sender and receiver in space (no shared address space), time (writer and reader need not co-exist), destination (no addressing — match by content), and form (any tuple format can be matched by an appropriate template).
Separation of computation and coordination: Linda is a coordination language deliberately orthogonal to the host computation language; a parallel program decomposes into a sequential computation plus a Linda coordination structure.
Generative communication: produced tuples have an existence independent of the producer — they live in the space, persist until consumed, and can be matched by any process. The producer-consumer decoupling this implies is what made tuple spaces attractive for systems with unpredictable producer/consumer matching.
Implementation tractable but not trivial: efficient Linda implementations distribute the tuple space (statically by tuple shape, dynamically by hashing), specialise frequent matching patterns, and treat in/rd as conditional rendezvous; significant systems-engineering work, but feasible.

Connections

Conceptual Contribution

Claim: Coordination of parallel and distributed processes can be elegantly expressed via a content-addressable shared tuple space accessed through four primitives (out, in, rd, eval); this decouples senders and receivers in space, time, destination, and form, and supports a clean separation of computation and coordination. Coordination is its own first-class concern, distinct from the computation it orchestrates.
Mechanism: Logically shared bag of tuples; associative pattern matching with typed wildcards; four primitive operations forming a small coordination language; embedded combination with any host computation language (C-Linda, Fortran-Linda, Java for JavaSpaces, etc.); distributed implementation via tuple-shape partitioning and matching specialisation.
Concepts introduced/used: Generative Communication, Linda (coordination), Tuple Matching, Tuple Spaces, Coordination Language, Separation of Computation and Coordination, Four Dimensions of Decoupling.
Stance: foundational systems-engineering paper.
Relates to: Direct ancestor of JavaSpaces (Sun, 1998), TSpaces (IBM, 1999), GigaSpaces (commercial), and the academic descendants KLAIM (De Nicola, Ferrari & Pugliese 1998 — Linda + mobile-agent locality), and (more loosely) Reo (Arbab 2004 — connector-based coordination as algebraic counterpoint to Linda’s tuple-space model). The conceptual move “coordination is a separate first-class concern from computation” is shared with Kowalski’s Algorithm = Logic + Control (1979) — algorithm = logic + control = computation + coordination — and with the entire blackboard-architecture line in AI. Within this vault Linda is the missing canonical reference under the existing Tuple Spaces concept stub. In the agent-communication setting, tuple spaces supply an alternative to KQML/FIPA-style facilitator mediation: where KQML’s Facilitators route messages by content, tuple spaces let agents publish content into a shared medium and let consumers match on what they want — the Agents and Artifacts (JaCaMo / CArtAgO) framework explicitly takes this stance, treating the shared environment as a first-class artefact agents communicate through. The pattern is also foundational for stigmergic coordination (the world is the shared medium) and for Ripple Effect Protocol-style sensitivity sharing among agents.

Tags

Chained Consensus

A consensus-protocol design in which agreement decisions are arranged in a chain (each block points to its parent via a Quorum Certificate) rather than as independent rounds. Commitment of a child commits the parent — and in HotStuff’s three-chain structure, the grandparent. Naturally amenable to pipelining, since the chain provides the dependency information needed to reason about overlapping decisions safely. The basis of essentially every BFT-PoS blockchain consensus protocol shipped after 2019.

In this vault

HotStuff

Yin et al.’s (2019) BFT consensus protocol with linear communication complexity (O(n) per decision in both the common case and view change) and responsiveness (commits at network speed, not max-timeout speed) — both improvements over PBFT. Achieves linearity via threshold-signature quorum certificates and uniform three-chain commit; chained variant pipelines three views into one message per leader. The consensus core of Diem, Aptos, Sui’s Mysticeti, and many recent BFT-PoS blockchains.

In this vault

Byzantine Agreement

The classical problem (Pease, Shostak & Lamport 1980; Lamport, Shostak & Pease 1982 Byzantine Generals Problem): get n processes to agree on a value when up to f of them may be Byzantine (arbitrarily faulty, including coordinating malicious behaviour). The standard bound is n ≥ 3f+1 for deterministic agreement with authenticated messages, n ≥ 3f+1 is also necessary in the partially-synchronous model. Practical algorithms: PBFT (Castro & Liskov 1999), HotStuff (Yin et al. 2019), Tendermint, Honeybadger.

In this vault

Practical Byzantine Fault Tolerance

Reference: Castro, M. & Liskov, B. (1999). Practical Byzantine Fault Tolerance. In 3rd Symposium on Operating Systems Design and Implementation (OSDI ’99), pp. 173–186, USENIX. Companion: Castro, M. (2001). Practical Byzantine Fault Tolerance. PhD thesis, MIT. Journal version: ACM Transactions on Computer Systems 20(4), pp. 398–461, 2002. Open access PDF (MIT CSAIL) · USENIX OSDI ’99 page · Journal version (BFT-TOCS)

Summary

Castro and Liskov demonstrate that Byzantine fault tolerance — agreement among 3f+1 replicas in the presence of up to f arbitrarily faulty (malicious, buggy, compromised) nodes — can be made practical: their protocol, PBFT, achieves throughput within a small factor of unreplicated service for realistic workloads, where prior BFT protocols had been orders of magnitude slower. The protocol assumes the partial-synchrony model (eventual upper bound on message delay) for liveness; safety holds in fully asynchronous networks. The core protocol is a three-phase primary-backup scheme — pre-prepare, prepare, commit — driven by a designated primary (replica p such that p ≡ v mod n for view number v). The primary orders client requests; the prepare phase ensures 2f+1 replicas agree on the order in the current view; the commit phase ensures persistence across view changes. A view change protocol replaces the primary if it is suspected of failure: backups time out, exchange certified message logs, and elect the next primary; the new primary reconstructs the longest committed prefix from the received certificates. The two key engineering moves that make BFT practical are (1) MAC vectors (one symmetric MAC per recipient) instead of public-key signatures on every message — public-key crypto is reserved for view changes — and (2) a careful checkpoint-and-garbage-collect mechanism that bounds memory and accelerates recovery. The paper applies PBFT to a Byzantine-fault-tolerant NFS implementation; performance is within 3% of unreplicated NFS for realistic file-system workloads. PBFT inaugurated 25+ years of practical BFT research and is the direct ancestor of modern blockchain consensus protocols including Tendermint, HotStuff, and Diem/Aptos’s BFT family.

Key Ideas

3f+1 replicas tolerate f Byzantine failures: the standard BFT bound (Lamport, Shostak & Pease 1982) — needed because Byzantine replicas can equivocate, so a 2f+1 quorum (sufficient against crash failures) can be split if f Byzantine replicas vote opposite ways to two halves of the honest set.
Three-phase commit driven by a primary: pre-prepare (primary assigns sequence number n to a request, broadcasts), prepare (each replica that accepts the pre-prepare broadcasts a prepare message; once 2f+1 prepare messages agree, the request is prepared), commit (each prepared replica broadcasts commit; once 2f+1 commit messages agree, the request is committed and executed).
View changes for primary failure: when a backup times out without progress, it broadcasts a view-change message containing certified prepared / committed certificates from the previous view; the new primary (next in round-robin) collects 2f+1 view-change messages and constructs a new-view containing the prepared requests that must be re-executed.
MAC vectors instead of signatures: every message carries a MAC for each recipient (computed under a pairwise symmetric key). One MAC is two orders of magnitude faster than a public-key signature; pairwise MACs are sufficient because Byzantine replicas cannot forge a MAC under a key they don’t know.
Checkpoints and garbage collection: every K requests, replicas take a checkpoint of state and broadcast a checkpoint message; once 2f+1 matching checkpoints exist (a stable checkpoint), older log entries can be discarded. Stable checkpoints also accelerate state transfer for recovering or lagging replicas.
Byzantine-fault-tolerant NFS: end-to-end demonstration that BFT can be deployed in production-style systems with manageable performance overhead — essential evidence that BFT was practical, not just theoretically interesting.
Safety always, liveness under partial synchrony: PBFT preserves safety (no two committed values disagree) under fully asynchronous networks; liveness requires partial synchrony (timeouts must eventually become accurate). FLP-compatible: the asynchronous gap is in liveness, not safety.

Connections

Conceptual Contribution

Claim: Byzantine fault tolerance can be made practical (within a small factor of unreplicated performance) by combining a three-phase primary-backup protocol with view-change recovery, MAC vectors instead of public-key signatures on the common path, and checkpoint-driven garbage collection. Safety holds in asynchronous networks; liveness requires partial synchrony.
Mechanism: Primary-backup protocol with 3f+1 replicas; three phases (pre-prepare, prepare, commit) each requiring 2f+1-strong quorum certificates; view-change protocol triggered by backup timeouts, electing the next primary by round-robin; MAC vectors with public-key crypto reserved for view changes; periodic stable checkpoints for log truncation and state transfer.
Concepts introduced/used: PBFT, Byzantine Agreement, View Change, MAC Vector, Stable Checkpoint, 3f+1 Quorum, Partial Synchrony.
Stance: systems-engineering paper / dissertation summary.
Relates to: Implements Byzantine agreement (Lamport, Shostak & Pease 1982 / Pease, Shostak & Lamport 1980) practically. Subject to the same FLP impossibility as crash-fault consensus, with the same partial-synchrony resolution. Pre-blockchain, BFT was largely a theoretical curiosity; PBFT proved deployment viable, but it took the explicit blockchain-as-economic-system framing of Bitcoin (Nakamoto 2008, not in vault) and especially of Tendermint (Buchman 2016) to drive industrial BFT adoption. Direct ancestor of HotStuff (Yin et al. 2019), which inherits PBFT’s three-phase structure but achieves linear communication complexity (vs PBFT’s quadratic) and responsiveness (no waiting for max network delay during normal operation). PBFT-style three-phase protocols underlie the consensus layers of Diem / Aptos, much of Hyperledger Fabric, and (with adaptations) Cosmos SDK chains. Compared to Raft / multi-Paxos: PBFT tolerates malicious nodes at the cost of 3f+1 replicas (vs 2f+1), three communication phases (vs two), and quadratic message complexity (vs linear); for crash-only environments Raft is simpler and faster.

Tags

#consensus #byzantine-fault-tolerance #pbft #castro #liskov #distributed-systems #foundations

Raft

Ongaro & Ousterhout’s (2014) crash-fault-tolerant consensus algorithm equivalent in capability to multi-Paxos but designed primarily for understandability. Decomposes consensus into Leader Election / Log Replication / safety; enforces a strong-leader discipline (logs flow only leader→follower); uses randomised election timeouts and term-numbered logical clocks. The dominant CP-style consensus algorithm in modern systems: etcd, Kubernetes, CockroachDB, TiKV, Consul.

In this vault

In Search of an Understandable Consensus Algorithm

In Search of an Understandable Consensus Algorithm (Extended Version)

Reference: Ongaro, D. & Ousterhout, J. (2014). In Search of an Understandable Consensus Algorithm. In 2014 USENIX Annual Technical Conference (USENIX ATC ’14), pp. 305–319. (Extended version on arXiv: 1404.4097.) Companion: Ongaro, D. (2014). Consensus: Bridging Theory and Practice. PhD thesis, Stanford University. Open access PDF (raft.github.io) · project home · arXiv:1404.4097 (extended)

Summary

Ongaro and Ousterhout introduce Raft, a consensus algorithm for replicated state machines that is equivalent in fault-tolerance and performance to multi-Paxos but designed primarily for understandability. The paper opens with the observation that despite Paxos’s status as the canonical consensus algorithm (Lamport 1998), it has consistently proved difficult for students and engineers to learn, reason about, and implement correctly: Lamport’s Paxos description is famously oblique, derivative explanations diverge, and most production “Paxos” implementations are actually significantly different algorithms. Raft is a deliberate engineering response to this state of affairs. It decomposes consensus into three relatively independent sub-problems — leader election, log replication, and safety — and adds an explicit strong leader discipline (logs flow only from leader to followers, never the reverse) plus a log-matching invariant that simplifies the consistency argument. Cluster membership changes are handled by a single-server-at-a-time approach (joint consensus is presented as the more general alternative). The paper includes a user study comparing student understanding of Raft against Paxos: across two universities, Raft scored substantially higher on comprehension tests after equivalent teaching time. Ongaro’s PhD thesis adds detail on snapshotting, log compaction, and client interaction. Raft is now the consensus algorithm of choice in the systems community: etcd (Kubernetes), CockroachDB, TiKV, Consul, RethinkDB, and many others use Raft directly; the algorithm is taught in distributed-systems courses worldwide. The paper deliberately demotes formal-verification rigour in favour of operator and engineer accessibility — a methodological stance with its own descendants in the systems literature.

Key Ideas

Three sub-problems: leader election (timeout-driven elections with randomised timeouts to break ties), log replication (leader appends entries and replicates to a majority), safety (committed entries must persist; only up-to-date candidates can win elections).
Strong leader: at any moment at most one leader exists per term; followers passively accept the leader’s appends. All client requests go through the leader; logs flow only leader→follower. This rules out an entire class of Paxos’s apparent symmetry.
Election restriction: a candidate’s vote request is rejected by any voter whose log is more up-to-date (longer term, or same term and longer index). Combined with majority voting, this guarantees that any newly elected leader contains all previously committed entries.
Log-matching invariant: if two logs contain an entry with the same index and term, then they are identical in all entries up to and including that index. This is enforced by the replication protocol (followers reject appends inconsistent with their last entry) and is the key property simplifying the safety argument.
Membership changes via joint consensus: to safely move from cluster C_old to C_new, the leader appends a joint configuration C_old,new that requires majorities of both configurations to commit; once committed, the leader appends the final C_new. (The thesis presents the simpler single-server-at-a-time method.)
Explicit terms as logical clocks: every server maintains a current term number; communications carry the sender’s term, and any server with a stale term steps down. Terms eliminate stale-leader pathologies that Paxos handles less directly.
Comprehensibility-as-design-criterion: the user-study results are presented as a primary contribution — the explicit thesis that algorithm design should weight understandability as it would performance or fault-tolerance.
Production realities: snapshotting for log compaction, linearizable read leases for read-only requests, client session-IDs for at-most-once semantics — covered in the thesis and absorbed into the standard Raft implementation patterns.

Connections

Conceptual Contribution

Claim: A consensus algorithm equivalent in fault-tolerance and performance to multi-Paxos can be designed primarily for understandability by decomposing consensus into independent sub-problems (leader election / log replication / safety), enforcing a strong-leader discipline, and adding a log-matching invariant; understandability should be a first-class design criterion alongside fault-tolerance and performance.
Mechanism: Strong-leader replicated-state-machine architecture; randomised election timeouts; AppendEntries RPC carrying previous-entry index+term so followers can reject inconsistent appends; vote-restriction by log up-to-date-ness; joint-consensus membership changes; user-study evaluation on graduate students.
Concepts introduced/used: Raft, Leader Election, Log Replication, Strong Leader, Log Matching Invariant, Joint Consensus, Term (as logical clock), Election Restriction.
Stance: systems-engineering paper with a methodological thesis (understandability as design criterion).
Relates to: Equivalent in capability to (multi-)Paxos (Lamport 1998 / 2001), explicitly and pointedly so — Raft is the re-presentation of Paxos’s solution space under a different organising principle. Subject to the same FLP impossibility result (Fischer, Lynch & Paterson 1985) and the same CAP Theorem trade-offs as Paxos: Raft chooses CP over AP in a network partition, sacrificing availability of the minority side. Crash-fault-tolerant only — Byzantine variants (PBFT, HotStuff) tolerate adversarial nodes but at the cost of a more expensive message protocol. Foundational for the modern CP-flavoured distributed-systems landscape: etcd / Kubernetes, CockroachDB, TiKV, Consul, MongoDB, and many others use Raft for cluster coordination; many “Paxos” implementations have been quietly rewritten as Raft for the same reasons Ongaro & Ousterhout argue. The paper’s methodological thesis — that designing for human comprehension is itself a research contribution — is influential beyond consensus and finds echoes in the design of Rust (over C++), TLA+ (over CSP-style notations), and the Pact-style choreographies that prefer DSL-shape over raw process-calculus terms.

Tags

#consensus #distributed-systems #raft #ongaro #replicated-state-machines #leader-election #foundations

The Part-Time Parliament

Reference: Leslie Lamport (1998). ACM Transactions on Computer Systems, 16(2):133-169 (minor corrections 2000). Source file: lamport-paxos.pdf. URL

Summary

The original exposition of the Paxos consensus algorithm, framed as an archaeological account of the part-time parliament of the (fictional) ancient Greek island of Paxos. Legislators drift in and out of the Chamber and messengers may lose, duplicate, or delay messages; nevertheless the parliament maintains a consistent ledger of decrees. Translated to distributed computing, this is the canonical solution to asynchronous fault-tolerant state-machine replication: a majority quorum protocol that guarantees safety (no two ledgers ever disagree on a decree) and makes progress whenever a majority of processes and their messages are eventually responsive.

The paper develops the single-decree Synod protocol first — choosing one value — using a ballot structure with three conditions (unique ballot numbers, pairwise-intersecting quorums, and a rule forcing a ballot’s decree to equal the latest decree of any earlier ballot whose quorum overlaps). It then generalises to multi-decree Parliament (multi-Paxos). The prose style (Greek-parable framing, archaeological footnotes) famously delayed the paper’s publication and shaped the oral tradition of the algorithm.

Key Ideas

Asynchronous consensus under crash failures and unreliable messaging via majority quorums
Two-phase protocol: prepare (collect promises / latest earlier votes) then accept (commit a value)
Ballot numbers totally ordered; any two quorums intersect; late ballots adopt an earlier committed value
Safety is unconditional; liveness depends on eventual synchrony plus a distinguished proposer
Multi-Paxos: amortise phase 1 across a sequence of decrees under a stable leader
State-machine replication as the canonical application

Connections

Conceptual Contribution

Claim: Fault-tolerant consensus is achievable in an asynchronous message-passing system with crash failures as long as a majority of processes is eventually live and can communicate, by requiring every decision-making quorum to intersect every other.
Mechanism: Ballots with unique, totally ordered numbers; each ballot has a quorum; a ballot succeeds iff its quorum all vote. Condition B3 — a ballot’s decree must match the decree of the latest earlier ballot in which any quorum member voted — propagates any already-committed value forward, preserving safety across leader changes.
Concepts introduced/used: Paxos, Synod protocol, ballots, quorums, proposer/acceptor/learner roles (implicit), state-machine replication, safety vs. liveness, leader election, eventual synchrony.
Stance: formal / algorithmic — an algorithm with a correctness proof disguised as archaeology.
Relates to: Paxos sidesteps Impossibility of Distributed Consensus with One Faulty Process (FLP) by relaxing liveness under worst-case asynchrony. It operationalises the happens-before order of Time Clocks and the Ordering of Events in a Distributed System (another Lamport paper) at the agreement level. Sits firmly in the CP corner of the CAP Theorem, trading availability during partitions for consistency. Contrasts with CALM Theorem, which identifies classes of computations that need no coordination at all.

Tags

The Extended Mind

Reference

Clark, Andy & Chalmers, David J. (1998). “The Extended Mind.” Analysis 58: 10–23. Reprinted in P. Grim (ed.), The Philosopher’s Annual vol. XXI, 1998.
HTML source: consc.net/papers/extended.html
(HTML-only; full prose captured below in the Summary.)

Summary

Clark and Chalmers ask where the mind stops and the world begins. Rejecting both the internalist “skin-and-skull” demarcation and Putnam/Burge semantic externalism, they advocate a third position: active externalism, on which environmental features play an active role in driving cognitive processes. Their illustrative ladder of Tetris-like cases — mental rotation, screen-button rotation, and a futuristic neural-implant rotation — is designed to show that the mere location of a computation (inside the skull vs. spread across agent and world) does not settle whether that computation is cognitive. Where a part of the world plays a functional role that would count as cognitive if performed in the head, it is part of the cognitive process. “Cognitive processes ain’t (all) in the head.”

The argument for active externalism rests on two-way coupling: when an organism and an external resource jointly govern behaviour, the coupled system is itself a cognitive system; remove the external component and behavioural competence drops as it would from removing brain tissue. This differs from standard semantic externalism, where the external element is causally remote and does little ongoing cognitive work. The celebrated case is Otto and Inga. Inga remembers the Museum of Modern Art is on 53rd Street and walks there; Otto has Alzheimer’s and relies on a notebook he always carries, consults, and trusts; he reads “MoMA is on 53rd Street” and walks there. Clark and Chalmers argue Otto’s notebook plays the same functional role Inga’s biological memory plays, so Otto genuinely believes — in advance of consultation — that MoMA is on 53rd Street. Belief, on the functionalist criterion, extends into the notebook.

The paper carefully distinguishes extended cognition from extended consciousness (they are not claiming Otto’s notebook is conscious), and lists criteria for candidate external beliefs: constancy of availability, direct availability when needed, automatic endorsement on retrieval, and past conscious endorsement. They anticipate objections — brittleness, bandwidth, privileged access — and argue these are differences of degree, not kind. The closing move is social and technological: language, institutions, and especially digital artefacts make extension pervasive, and selves become “spread into the world.”

Key Ideas

Active externalism: environment plays an active, ongoing causal role in cognition, not merely a distal referential role.
Parity principle: if a process done in the head would count as cognitive, doing it in the world also counts as cognitive.
Coupled systems: two-way interaction between organism and artefact yields a single cognitive system.
Otto’s notebook: dispositional beliefs can be stored in external media that are reliably available, automatically endorsed, and trusted.
Epistemic action (Kirsh & Maglio): manipulating the world to aid cognitive processes such as recognition and search.
Criteria for extended belief: constancy, accessibility, automatic endorsement, prior endorsement.
Not extended consciousness: the thesis concerns cognitive/functional states, not phenomenal experience.
Self as spread: language, notebooks, and culture routinely extend cognitive systems beyond the biological organism.

Connections

Computational Boundary of a Self — directly engages where to draw the self/system boundary; Clark–Chalmers is the classic argument that the boundary is not skin.
True Believers - The Intentional Strategy and Why It Works — Dennett’s intentional stance makes belief ascription pattern-based, compatible with extension into notebooks and devices.
Ascribing Mental Qualities to Machines — McCarthy’s permissive attribution of beliefs/goals to artefacts, a precondition for taking Otto’s notebook seriously.
The Society of Mind — Minsky’s distributed-mind intuition, internalised; Clark–Chalmers push the distribution outward.
Intelligence Without Representation — Brooks’s “world as its own best model” is a kindred thesis from robotics.
Actor Model, A Universal Modular Actor Formalism for Artificial Intelligence — coupling among autonomous components maps onto extended cognitive systems.
Agent Architecture — extended-mind arguments motivate agent designs that offload state to environment (stigmergy, blackboards, shared memory).
Semantic Web — if digital artefacts can be cognitive scaffolding, shared ontologies literally extend minds.

Conceptual Contribution

Intelligence Without Representation

Reference

Brooks, Rodney A. (1991). “Intelligence without representation.” Artificial Intelligence 47: 139–159. (Received September 1987.)
PDF: people.csail.mit.edu/brooks/papers/representation.pdf
Local: brooks1991_representation.pdf

Summary

Brooks challenges the dominant symbol-manipulation paradigm of classical AI, arguing that “representation is the wrong unit of abstraction in building the bulkiest parts of intelligent systems.” Drawing on an evolutionary argument — 3.5 billion years were spent evolving sensorimotor and survival competence, and only a few thousand years on “expert” symbolic knowledge — he claims the hard part of intelligence is mobility, vision, and acting in dynamic environments, not the formal problem-solving that dominated early AI. The “blocks-world” style of AI succeeds only because researchers have already factored out perception and motor action, relegating them to input/output black boxes.

In place of centralized symbolic architectures, Brooks proposes building autonomous mobile robots he calls “Creatures,” decomposed by activity rather than by function. Each activity-producing layer connects sensing to action directly and runs in parallel; higher layers are incrementally added on top of lower, already-working layers without a central symbolic world model. This is the subsumption architecture. The slogan is “the world is its own best model”: rather than maintaining an internal representation the robot re-perceives what it needs.

The paper’s philosophical payload is a rejection of the sense–model–plan–act pipeline and of the assumption that intelligence can be decomposed into modules trading symbolic messages. Brooks argues this methodological commitment — that perception delivers a human-style Merkwelt that central reasoning can operate on — is a form of self-deception, since each species and each robot inhabits its own Merkwelt. Intelligence is to be built bottom-up, situated and embodied, tested continuously against the real world.

Key Ideas

Situatedness and embodiment as design primitives: Creatures must cope with a dynamic environment and have some purpose in being.
Decomposition by activity, not function: layers of task-achieving behavior (avoid, wander, explore) replace perception → modeling → planning → action pipelines.
Subsumption architecture: higher competence layers inhibit/subsume lower ones while lower continue running.
No central representation: “the world is its own best model”; no shared symbolic world model between layers.
Evolutionary time argument: sensorimotor intelligence is the hard, ancient core; symbolic expertise is a thin late veneer.
Critique of abstraction: abstracting away perception and action is how AI self-deceives about having solved problems.
Hypothesis (H): representation is the wrong primitive for building intelligent systems.

Connections

Subsumption Architecture — this paper is the manifesto.
Intelligent Agents Theory and Practice — Wooldridge & Jennings use Brooks as the exemplar of reactive agents, contrasted with deliberative BDI agents.
The Society of Mind — shares the anti-monolithic, many-small-agents intuition, though Minsky retains representations.
Multi-Agent Systems — reactive/behavior-based approaches feed directly into swarm and MAS work.
Actor Model — independent parallel activity producers without a central controller.
A Universal Modular Actor Formalism for Artificial Intelligence — kindred rejection of centralized control.
Agent Architecture — subsumption is a canonical architecture contrasted with BDI, layered, hybrid.
Contrast with Knowledge Representation, Ontologies, Advice Taker — papers that double down on representation.

Conceptual Contribution

Distributed Snapshots Determining Global States of Distributed Systems

Distributed Snapshots: Determining Global States of Distributed Systems

Reference: K. Mani Chandy, Leslie Lamport (1985). ACM Transactions on Computer Systems, 3(1):63-75. Source file: chandy-lamport-1985.pdf. URL

Summary

Introduces the Chandy-Lamport distributed-snapshot algorithm: a decentralised procedure by which processes in an asynchronous message-passing system can jointly record a consistent global state without halting the underlying computation and without any shared clock. The recorded state may never have existed at a single instant, but it is reachable from the initial state and can reach the final state; in particular, it correctly detects any stable property (deadlock, termination, token loss, etc.).

The algorithm works on a strongly connected graph of FIFO channels: the initiator records its local state and sends a special marker on every outgoing channel; upon first receipt of a marker on an incoming channel, a process records its own state, records the incoming channel as empty, and propagates markers on its outgoing channels; subsequent markers terminate channel recording. The paper’s “photographers of migrating birds” metaphor became canonical for the problem. The snapshot defines a consistent cut in the happens-before order and is the foundation for distributed debugging, checkpointing, and stable-property detection.

Key Ideas

Global state = set of process states plus set of channel (message-in-transit) states
Marker messages as in-band synchronization tokens on FIFO channels
A recorded snapshot is reachable from the pre-snapshot state and reaches the post-snapshot state, even though it may never have held simultaneously
Stable properties (termination, deadlock, lost tokens) can be decided on any recorded snapshot
No shared clock, no halting of the underlying computation, fully decentralised initiation
Requires FIFO channels and eventual delivery; channel state = messages sent before marker but received after

Connections

Conceptual Contribution

Claim: A consistent global state of an asynchronous distributed system can be recorded by a fully local algorithm using in-band marker messages, without stopping the computation and without shared clocks.
Mechanism: An initiator records its state and floods markers. Each process, on first marker arrival on channel c, records its own state and treats the pre-marker messages on c as empty; for subsequent incoming channels it records the messages received after its own state-recording and before the marker as the channel’s recorded state. FIFO channels guarantee consistency of the resulting cut.
Concepts introduced/used: Consistent cut, global state, stable property, marker protocol, in-band control, distributed termination detection, distributed deadlock detection, checkpointing.
Stance: formal / algorithmic.
Relates to: Builds directly on the happens-before relation and logical clocks of Time Clocks and the Ordering of Events in a Distributed System — a snapshot is a consistent antichain in that partial order. Complements CALM Theorem, which characterises computations whose results are insensitive to message ordering and therefore need no snapshot for correctness. The flooding of markers over a connected topology is a structural cousin of Gossip Protocols, though snapshot markers carry exact-once semantics rather than probabilistic diffusion.

Tags

The Protection of Information in Computer Systems

Reference: Jerome H. Saltzer, Michael D. Schroeder (1975). Proceedings of the IEEE, 63(9):1278-1308. Source file: saltzer-schroeder-1975.pdf. URL

Summary

The foundational tutorial on information protection in computer systems, concentrating on the architectural structures (hardware and software) necessary to support protection. Organised as three sections: (I) basic principles, functions and elementary protection/authentication mechanisms; (II) descriptor-based protection architectures and the relation between capability systems and access-control-list systems; (III) state of the art and research projects.

The paper is most remembered for its eight design principles (economy of mechanism, fail-safe defaults, complete mediation, open design, separation of privilege, least privilege, least common mechanism, psychological acceptability). It gives precise definitions for principal, capability (“an unforgeable ticket”), access control list, domain, protected subsystem, confinement, and distinguishes discretionary from nondiscretionary controls. Saltzer and Schroeder frame the tension between capability-oriented (ticket-oriented) and list-oriented systems that still shapes modern access control.

Key Ideas

Three categories of violation: unauthorized information release, unauthorized modification, unauthorized denial of use
Eight design principles for protection mechanisms (least privilege, fail-safe defaults, complete mediation, etc.)
Functional taxonomy: unprotected / all-or-nothing / controlled sharing / user-programmed sharing
Capability (“ticket-oriented”) vs. access-control-list (“list-oriented”) as dual descriptor structures
Protected subsystems as encapsulated domains with controlled entry points
Authentication vs. authorization distinction; the notion of principal as the unit of accountability
Confinement problem: preventing a borrowed program from leaking the data it accesses

Connections

Conceptual Contribution

Claim: Protection is not a bag of techniques but an architectural discipline; a small set of design principles (especially least privilege, fail-safe defaults, complete mediation, economy of mechanism) together with the capability/ACL descriptor abstraction is sufficient to organise the design space of secure systems.
Mechanism: Descriptor-based protection: every access to a protected object passes through a descriptor (capability or ACL entry) managed by a reference monitor. Protected subsystems encapsulate data with domain-specific procedures callable only at designated entry points. Principals are authenticated once; authorization is then mediated per access.
Concepts introduced/used: Principle of Least Authority (least privilege), Capability Security, Object Capability Security, Ambient Authority (as an antipattern), Confused Deputy (implicit in the delegation discussion), access control list, protected subsystem, confinement, complete mediation, fail-safe defaults, separation of privilege, economy of mechanism, psychological acceptability.
Stance: engineering / systems — normative architectural guidance grounded in Multics experience.
Relates to: Provides the vocabulary used by Object Capability Security and Capability Security work (Dennis & Van Horn, Hydra, KeyKOS, EROS, Capsicum). Its least-privilege principle underlies Principle of Least Authority, and its critique of pervasive authority is the ancestor of Ambient Authority and Confused Deputy analyses. The architectural posture prefigures End-to-End Arguments in System Design (Saltzer again) and is philosophically aligned with LangSec’s call for narrow, verifiable interfaces. Fundamental to Distributed Security.

Tags

A Framework for Representing Knowledge

Reference

Minsky, Marvin (1974). “A Framework for Representing Knowledge.” MIT-AI Laboratory Memo 306, June 1974. Reprinted in P. Winston (Ed.), The Psychology of Computer Vision, McGraw-Hill 1975; shorter versions in Haugeland (ed.) Mind Design, MIT Press 1981, and in Collins & Smith (eds.) Cognitive Science, Morgan-Kaufmann 1992.
PDF: courses.media.mit.edu/2004spring/mas966/Minsky%201974%20Framework%20for%20knowledge.pdf
MIT DSpace: dspace.mit.edu/handle/1721.1/6089
Local: minsky1974_frames.pdf

Summary

Minsky argues that the “chunks” of reasoning, language, memory, and perception must be larger and more structured than the fine-grained representations (logical predicates, production rules, semantic nets of atoms) favored by then-contemporary AI and psychology. He proposes the frame as a data structure for representing a stereotyped situation — being in a certain kind of living room, attending a birthday party, viewing a cube from an angle. A frame has fixed top-level facts about the situation plus terminals (slots) that must be filled by specific instances meeting marker conditions; slots carry default assignments that are easily displaced by better-fitting data.

Frames are grouped into frame-systems whose members share terminals and whose transformations represent actions, cause-effect relations, or shifts of viewpoint (e.g., walking around a room: different visual frames share identity of the objects seen). Frame-systems are linked by an information-retrieval network that proposes replacement frames when matching fails. The theory covers visual scene analysis, linguistic understanding (discourse and story frames), memory and analogy, and default/non-monotonic reasoning — all as instances of selecting a frame, matching it against the situation, and repairing the match when surprises occur.

The apology in the paper is explicit: Minsky proposes representations without fully specifying the processes that use them, and he admits the basic frame idea is in the Bartlett “schema” / Kuhn “paradigm” tradition. The novelty is the frame-system and the integration of defaults, expectations, markers, and a retrieval network into a single architecture for common-sense thought. The paper closes Part 1 with vision and imagery; later parts address language, memory, control, and an appendix arguing that traditional logic is unsuited to realistic approximations.

Key Ideas

Frame: structured data-stereotype for a recurring situation, with fixed top-level and slotted terminals.
Terminal markers: constraints (person / object of sufficient value / sub-frame of a kind) on what may fill a slot.
Default assignments: terminals normally pre-filled, easily displaced; supports reasoning by example and non-monotonic inference.
Frame-systems and shared terminals: different frames of the same system describe a scene from different viewpoints; transformations among frames model action, perspective, causation.
Matching and replacement: an information-retrieval network offers alternative frames when the current frame fails; surprises drive learning.
Top-down expectation over bottom-up data: perception and language understanding are guided by expectations from proposed frames.
Against purely logical representation: common sense needs approximation and default reasoning, not quantified certainty.

Connections

Frames (AI) — this is the founding document.
The Society of Mind — Minsky’s later book generalizes the many-small-structures intuition; frames become agents.
Trans-Frames — later Minsky concept building on frame-system transformations for actions and causes.
Knowledge Representation — frames are one of the big three paradigms alongside logic and semantic nets.
Ontologies, Handbook On Ontologies — class/slot/default structure of frames is ancestral to object-oriented ontology languages (KL-ONE, F-Logic, OWL classes).
Ontolingua Portable Ontology Specifications, Toward Principles for the Design of Ontologies Used for Knowledge Sharing — frame-style slot-and-filler vocabulary.
A Common Ontology Of ACLs — shared terminals are conceptually parallel to shared performative slots.
Semantic Web — RDF/OWL frame-like class modelling traces to this paper.
Contrast with Intelligence Without Representation — Brooks’s opposite pole on whether structured representations are even needed.
Abnormality Predicate — default reasoning formalized later by McCarthy.

Conceptual Contribution

Three-Party Handoff

A CapTP technique deployed in Cap’n Proto RPC: when client A calls server B and B returns a capability pointing to a third party C, the RPC layer arranges for A to talk directly to C for subsequent calls — eliminating the quadratic relay overhead that would arise if every call to the third-party capability had to round-trip through B. Crucial for the rich object-graph topologies natural to capability-secure systems.

In this vault

CapTP

CapTP — Capability Transport Protocol

The E language’s foundational protocol for sending object references and invocations across the network while preserving capability discipline and supporting promise pipelining.

In this vault

Capn Proto

Cap’n Proto: Capability-Secure RPC and Serialization

Reference: Varda, K. (2013–present). Cap’n Proto: Cap’n Proto Is Insanely Fast Data Interchange Format and Capability-Based RPC System. https://capnproto.org/. (Citation-only — open-source project + RFCs; key design documents: Cap’n Proto RPC Specification and the Three-Party Handoff design note.) Open access — RPC spec · project home · rpc.capnp source (GitHub)

Summary

Kenton Varda (formerly principal author of Google’s Protocol Buffers v2) develops Cap’n Proto as the modern engineering realisation of capability-secure RPC. The project has two parts. The serialisation format is a zero-copy binary encoding designed so that messages can be read directly out of the wire bytes without parsing — O(1) field access, no decode pass, the on-the-wire layout is the in-memory layout. This is a substantial improvement over Protocol Buffers, which require parsing into a separate object representation. The RPC protocol (Cap’n Proto RPC, conceptually descended from the CapTP of E and Spritely) carries capabilities — references to remote objects that the receiver may invoke — alongside ordinary data. Two design moves make the RPC protocol practically deployable as a capability-secure substrate. Promise pipelining: when the client invokes a method that returns a capability, it can immediately invoke methods on the promised return value before the original call has completed; the RPC layer collapses the chain into a single round-trip. Three-party handoff: when the server returns a capability that points to a third party, the client can shortcut subsequent calls directly to the third party rather than continuing to relay through the original server — supporting the rich object-graph topologies natural to capability-secure systems without quadratic relay overhead. Cap’n Proto’s RPC protocol is the modern realisation of CapTP and the cleanest available substrate for object-capability systems crossing machine boundaries; it underpins Cloudflare Workers’ inter-worker capability passing, Sandstorm.io’s grain isolation model, and an increasing number of capability-secured agent and microservice systems.

Key Ideas

Zero-copy serialisation: messages are encoded so that the on-the-wire byte layout is the in-memory layout — O(1) field access, no parsing pass. Substantial throughput / latency win over Protocol Buffers.
Capabilities as first-class wire values: an RPC parameter or return value can be a capability — a reference to a remote object the receiver may invoke. The RPC layer handles capability lifecycle (reference counting across the wire), revocation, and forwarding.
Promise pipelining: when a method returns a capability, the client can invoke methods on the promised return before the call completes. The RPC layer batches the dependent calls into the original request; a chain of N pipelined calls becomes one round-trip rather than N. Inherits the CapTP promise-pipelining technique.
Three-party handoff: when client A calls server B and B returns a capability pointing to a third party C, the RPC layer arranges for A to talk directly to C for subsequent calls — eliminating the quadratic relay overhead that would arise if every call to the third-party capability had to round-trip through B. Crucial for the rich object-graph topologies of capability-secure systems.
Reference counting and revocation across the wire: the RPC layer maintains capability reference counts on both ends; capabilities can be revoked unilaterally by the holder of the underlying object, and revocation propagates correctly even in the presence of promise pipelining and three-party handoff.
No security model imposed by the format itself: Cap’n Proto can be used as a plain serialisation format (without RPC); the capability layer is opt-in. This makes it deployable in heterogeneous environments where some peers participate in the capability protocol and others do not.
Production deployment: Cloudflare Workers, Sandstorm.io, and an increasing number of capability-aware microservice systems use Cap’n Proto’s RPC layer in production; it is the de facto modern CapTP.

Connections

Conceptual Contribution

Claim: Capability-secure RPC can be made fast enough for production microservice deployment by combining zero-copy serialisation (removing the parse pass) with first-class wire-level capabilities (so capability passing is a primitive of the RPC layer, not a layer above it). Two design moves — promise pipelining (collapse dependent-call chains into one round-trip) and three-party handoff (let A talk directly to C after B returns a C-capability) — eliminate the principal performance objections to capability-secure RPC.
Mechanism: Zero-copy binary message format; capability table per RPC connection, with reference counts maintained on both ends; promise-pipelining mechanism collapsing dependent calls; three-party handoff protocol; revocation propagation across the capability graph.
Concepts introduced/used: Capn Proto RPC, Three-Party Handoff, Promise Pipelining (CapTP heritage), Zero-Copy Serialisation, Capability Reference Counting.
Stance: systems engineering / open-source project + design notes.
Relates to: Direct modern descendant of CapTP — the capability transport protocol of E (Miller, 2006) and Spritely (Lemmer-Webber, Farmer & Sims 2025). Promise pipelining and three-party handoff are not new to Cap’n Proto — they are CapTP’s signature techniques — but Cap’n Proto is their first widely-deployed engineering realisation in a format performant enough for general microservice use. Conceptual sibling of Macaroons and SPKI-SDSI capability certificates: all three are answers to “how do you do capability security across machine boundaries?” with different trade-offs (Cap’n Proto = stateful RPC; Macaroons = stateless tokens; SPKI = certificate chains). For agent communication, Cap’n Proto’s three-party handoff is precisely the mechanism that makes capability-secure delegation between LLM agents practical: agent A can grant agent B access to a capability backed by service C, and B can then talk directly to C without A mediating each call. The Sandstorm.io / Cloudflare Workers deployment patterns are the closest production analogue of what capability-secure multi-agent systems need.

Tags

#capability-security #captp #capn-proto #rpc #serialisation #varda #spritely-lineage

Verifiable Credential

A W3C-standardised signed assertion (JSON-LD or JWT) issued by one DID-identified party (the issuer) about another DID-identified party (the subject). Carries issuer, credentialSubject, dates, claims, and a cryptographic proof. Supports selective disclosure (BBS+ signatures), zero-knowledge predicates (zk-SNARK proofs over claims without revealing them), and revocation via status-list credentials. Presented to a verifier via a Verifiable Presentation.

In this vault

Decentralized Identifier

A W3C-standardised globally-unique URI of the form did:method:identifier whose resolution is governed by a DID method algorithm rather than by any centralised registry. The portion before the colon names the resolution method (did:key, did:web, did:ion, …); the resolution result is a DID Document containing public keys, service endpoints, and verification relations. The substrate of self-sovereign identity; the modern descendant of SPKI/SDSI capability-style PKI.

In this vault

Decentralized Identifiers

W3C-standardised globally resolvable identifiers (DIDs) that are created, owned and controlled by their subject without a central registry. Each DID resolves to a DID Document containing public keys and service endpoints, supporting self-sovereign agent identity.

In this vault

Linked Local Names

SDSI’s mechanism for distributed naming without a global registry: a name like K_alice's bob's friends is resolved by chaining lookups across local namespaces — first K_alice looks up “bob” in her namespace and finds K_bob, then K_bob looks up “friends” in his namespace, and so on. No central authority needed. The conceptual ancestor of DID-style namespacing in modern decentralised-identity standards.

In this vault

Trustworthy Proxies - Virtualizing Objects with Invariants

Trustworthy Proxies: Virtualizing Objects with Invariants

Reference

Van Cutsem, Tom; Miller, Mark S. “Trustworthy Proxies: Virtualizing Objects with Invariants.” In Proceedings of the 27th European Conference on Object-Oriented Programming (ECOOP 2013), Montpellier, France, July 2013. LNCS 7920, pp. 154-178, Springer. URL

Summary

This ECOOP paper is the design rationale for the Proxy API that became standard in ECMAScript 6. Proxies are wrapper objects that virtualise an interface by intercepting all operations via trap functions - a technique essential for membranes, revocable references, access-control wrappers, profilers, taint tracking, higher-order contracts, and lazy/remote object references. The problem the paper addresses: in a language that also has language invariants (e.g., ES5’s non-extensibility and non-configurability - “frozen” objects), can a proxy faithfully virtualise an object that has such invariants without giving up on the language’s guarantee that those invariants hold?

The authors formalise the tension. A “universal, monotonic” language invariant (such as Object.isFrozen(x) ⇒ x.p consistently designates the same value forever) is what lets developers, compilers, and security reviewers locally reason about objects in a dynamic language. A naive proxy API breaks this: a proxy could return different values each time for a property of a target that is frozen, defeating the invariant. The paper’s key contribution is the design of a Proxy API in which proxies refer directly to a target object, and the proxy machinery verifies invariants after each trap call, raising a TypeError if a trap would violate a target’s invariant. This is called invariant enforcement. With it, the language-level frozen-object guarantee holds for proxies too, so clients can still blindly trust Object.isFrozen.

The paper introduces a formal calculus, λ_TP (lambda-TP), an extension of the lambda calculus with proxies and invariant enforcement, and uses it to prove that invariants are preserved. It then demonstrates several important ocap-flavoured access-control abstractions built on trustworthy proxies: revocable membrane references, read-only views, and contract wrappers. This design is foundational to the secure-EcmaScript / hardened-JS / Agoric-SES story, and is the plumbing beneath Object.freeze-based ocap disciplines in modern JS - including MetaMask’s LavaMoat, Endo, and the Spritely-adjacent JavaScript tooling. It is the companion paper to Distributed Electronic Rights in JavaScript (ESOP 2013).

Key Ideas

Proxies = trap-based virtualisation; handlers intercept get, set, has, delete, etc.
Language invariants: universal, monotonic properties of objects (non-extensibility, non-configurability, frozen) that clients and compilers rely on.
The trust problem: naive proxies can claim to wrap a frozen target yet return inconsistent values; isFrozen would have to return false for all proxies, losing transparency.
Invariant enforcement: proxy holds a direct reference to its target; after each trap, the runtime checks that the returned value is consistent with the target’s invariants; inconsistency throws.
λ_TP calculus: formal model of proxies + invariant enforcement in the lambda calculus.
Membranes: with trustworthy proxies, one can build revocable membranes that transitively wrap all outgoing references and revoke the whole object subgraph atomically.
Foundational for SES/hardened-JS: without trustworthy proxies, freezing is not sufficient to ground ocap claims across wrapper boundaries.
This design became ES6 Proxies and the modern JS reflection API.

Connections

The Heart of Spritely - Distributed Objects and Capability Security
E Language - membrane / facet patterns come straight from the E tradition.
CapTP - remote object references across vats are naturally implemented as trustworthy proxies.
Capability Security, Object Capability Security
Ambient Authority - membranes built on proxies are the main device for stripping ambient authority from mobile code.
Confused Deputy - read-only views and attenuated proxies prevent confused-deputy scenarios.
Principle of Least Authority - attenuated proxies are POLA at the reference level.
Distributed Security
Security Kernel Lambda Calculus - λ_TP is a close cousin, also a lambda calculus for ocap reasoning.
Capability Revocation - revocable membranes are the definitive technique, enabled by this API.
Promise Pipelining - remote promises in JS are implemented on top of proxy-like handlers.

Conceptual Contribution

Distributed Electronic Rights in JavaScript

Reference

Miller, Mark S.; Van Cutsem, Tom; Tulloh, Bill. “Distributed Electronic Rights in JavaScript.” In Programming Languages and Systems - 22nd European Symposium on Programming (ESOP 2013). LNCS 7792, pp. 1-20, Springer, 2013. URL

Summary

This ESOP 2013 paper reports on the effort to turn JavaScript into the ubiquitous distributed object-capability fabric for smart contracts and erights (electronic rights). JavaScript already has ubiquity, a memory-safe object model, and first-class functions with lexical closure; what it lacks, the authors argue, is the three missing ingredients for robustly composing mutually suspicious code across machines: a secure subset, a promise-based distributed object model, and persistent resilience. These are provided respectively by SES (Secure EcmaScript, an ocap subset of ES5), the Q promise library (distributed-JS with eventual-send !), and NodeKen (distributed orthogonal persistence on Node.js, built atop the Ken system). Together they form Dr. SES - Distributed Resilient Secure EcmaScript.

The paper walks through the whole stack. SES freezes primordials, whitelists globals, and makes def(obj) produce defensively consistent tamper-proof records. confine(src, endowments) safely evaluates untrusted JS with a supplied endowments record, giving first-class mobile-code capability security. The Q library adds ! (eventual-send) so that p!getX() sends a message to whatever p will designate when resolved - this is promise pipelining, generalised to remote and failed promises. NodeKen provides “every message ever sent will be delivered in order exactly once,” allowing programmers to ignore partition and crash.

The demonstration is a 42-line escrow exchange contract: two mutually suspicious parties wish to swap goods/money via an untrusted escrow agent, and the Dr. SES code expresses the contract clearly and executes safely across distributed JS event loops. This paper is the crucial bridge between Miller’s E tradition and the modern web - its ideas flow directly into the TC39 proxies proposal, ECMAScript frozen realms, hardened-JS / LavaMoat, Agoric’s Zoe, and the MetaMask / secure-ECMAScript supply-chain work.

Key Ideas

Dr. SES = SES + Q + NodeKen: secure ocap JS + distributed promises + orthogonal persistence.
SES: ocap subset of ES5 - frozen primordials, whitelisted globals, powerless-by-default imports, def() for defensive consistency, confine() for safe mobile code.
Eventual-send !: target!method(args) is a non-blocking message-send returning a promise; distribution-transparent.
Promise pipelining as the basic async composition: chained .then on a remote promise reduces round-trips.
Defensively consistent objects: maintain invariants despite malicious clients.
WeakMap for rights amplification: identity-keyed tables let a facet holder recover the full object.
Escrow exchange in 42 lines: demonstrates that non-trivial smart contracts become pedagogically small under the right fabric.
NodeKen / Ken: survives crashes and partitions by orthogonal checkpointing, so distributed programmers can reason as if messages were reliable.

Connections

The Heart of Spritely - Distributed Objects and Capability Security - Spritely’s ocapN and Goblins are the Guile-side reincarnation of Dr. SES principles.
E Language - Dr. SES is E’s design translated into JavaScript.
CapTP - Q’s eventual-send over the wire is a CapTP-spirit protocol.
Capability Security, Object Capability Security
Ambient Authority - SES’s frozen-globals / powerless-imports directly attacks ambient authority in JS.
Confused Deputy - confine() with explicit endowments is an anti-confused-deputy idiom.
Principle of Least Authority - endowments are POLA made concrete.
Distributed Security
Security Kernel Lambda Calculus
A Universal Modular Actor Formalism for Artificial Intelligence
Actor Model
Vat Model - each JS event loop is a vat.
Promise Pipelining - Q is the mass-market pipelining library.

Conceptual Contribution

Robust Composition - Towards a Unified Approach to Access Control and Concurrency Control

Robust Composition: Towards a Unified Approach to Access Control and Concurrency Control

Reference

Miller, Mark Samuel. Robust Composition: Towards a Unified Approach to Access Control and Concurrency Control. PhD Dissertation, Johns Hopkins University, May 2006. Advisor: Jonathan S. Shapiro. Readers: Scott Smith, Yair Amir. URL

Summary

Mark Miller’s dissertation is the foundational synthesis of the object-capability tradition. It argues that the act of composing separately written programs so that they cooperate rather than destructively interfere is the fundamental problem that has limited the scale and functionality of software systems. The thesis proposes a unified framework that binds together access control and concurrency control as two faces of the same compositional discipline: each message send is at once an authority-propagation event and a concurrency-interleaving event, and both must be disciplined together if we are to compose code written by mutually suspicious authors on mutually suspicious machines.

Miller extends decades of object-oriented progress from its comfortable setting (sequential, single-machine, benign components) to the hostile general case: concurrent, distributed, and potentially malicious components. The vehicles for this are the E programming language - a distributed, persistent, object-capability language built around vats, near/far references, eventual-send, promise pipelining, and CapTP - and CapDesk, a virus-safe desktop built in E. Together E and CapDesk form working embodiments of the thesis: authority is only granted by reference-passing along the message graph, and concurrency hazards (deadlock, non-determinism, plan interference) are tamed by the communicating-event-loop / vat model rather than by shared-memory locks.

The dissertation pulls together and formalises the lineage from Dennis & Van Horn, Hardy’s confused deputy, KeyKOS/EROS, Actor-model eventual send, and the SPKI/Granovetter diagram tradition, and it is by far the most-cited reference for object-capability security. Its substantive chapters cover attenuating authority, distributed concurrency control, promise pipelining, the “excess authority as gateway to abuse” argument, and the POLA design discipline.

Key Ideas

Unification of access and concurrency control: both are consequences of disciplining what one object can do to another across a message send.
Object-capability model: authority == what references you hold; “only connectivity begets connectivity.”
Vats and communicating event loops: each vat is a single-threaded turn-taking event loop; cross-vat calls are eventual sends returning promises.
Promise pipelining: chained messages to not-yet-resolved promises reduce round-trips and compose naturally as plans.
CapTP: the cryptographic capability transport protocol that preserves object-capability semantics across mutually-suspicious machines.
Defensive consistency: an object defends its own invariants against arbitrary clients.
POLA as design discipline: hand out only the authority actually needed for each delegation.
CapDesk: demonstrates that a virus-safe desktop is achievable by threading object-capabilities through the UI/shell layer (powerboxes, caplets).

Connections

The Heart of Spritely - Distributed Objects and Capability Security - Spritely is the direct modern successor carrying Miller’s E design forward into Goblins/Guile.
E Language - E is the concrete language Miller designs and evaluates here.
CapTP - Miller’s distributed capability transport, specified in detail.
Capability Security and Object Capability Security - this thesis is the canonical statement of the ocap model.
Ambient Authority - Miller’s thesis is the source of the modern critique of ambient authority.
Confused Deputy - Miller reframes Hardy’s confused-deputy problem as a composition failure.
Principle of Least Authority - POLA is given its definitive formulation here.
Distributed Security - the thesis generalises ocap security to distributed settings.
Security Kernel Lambda Calculus - close kin in the formal-ocap tradition.
A Universal Modular Actor Formalism for Artificial Intelligence - the Actor model is one of E’s direct intellectual ancestors.
Actor Model - vats and eventual sends are the ocap-refined descendants of Hewitt’s actors.
Vat Model - the vat abstraction is introduced and justified here.
Promise Pipelining - Miller gives the definitive account of pipelining in this thesis.

Conceptual Contribution

Capability Myths Demolished

Reference

Miller, Mark S.; Yee, Ka-Ping; Shapiro, Jonathan S. Capability Myths Demolished. Technical Report SRL-2003-02, Systems Research Laboratory, Johns Hopkins University, 2003. URL

Summary

This short, polemical technical report dismantles three widely repeated myths about capability-based security that had accreted in the literature over the preceding two decades and were being cited as reasons to avoid capability models or to pile extra access checks on top of them. The three myths are: (1) the Equivalence Myth - that ACL systems and capability systems are formally equivalent views of Lampson’s access matrix; (2) the Confinement Myth - that capability systems cannot enforce confinement; and (3) the Irrevocability Myth - that capability-based authority cannot be revoked.

The authors’ strategy is to disentangle three very different things all called “capability” in the literature: Model 2 (capabilities-as-rows of the access matrix), Model 3 (capabilities-as-keys / unforgeable bitstrings), and Model 4 (object-capabilities, where capabilities are object references in a memory-safe object language). They define seven security properties - including “no designation without authority,” dynamic subject creation, subject-aggregated authority management, and composable confinement - and show how the three models differ on each. Under this lens, the Equivalence Myth collapses: ACLs and object-capabilities have fundamentally different rules for how the access matrix is updated, even if both can be drawn as an access matrix at an instant.

The Confinement Myth is refuted by pointing to KeyKOS factories (Hardy 1988) and the EROS constructor, which demonstrably achieve confinement in object-capability systems. The Irrevocability Myth is refuted via the Redell forwarder/facet pattern (1974), elegantly explained with a simple diagram: Alice hands Bob a forwarder to Carol and keeps the revoker; dropping the revoker drops Bob’s access. The paper is the go-to reference whenever these myths resurface and is essential intellectual groundwork for the ocap tradition.

Key Ideas

Three distinct capability models: capabilities-as-rows, capabilities-as-keys, object-capabilities - not interchangeable.
The access-matrix snapshot lies: static snapshots ignore the update rules that actually distinguish ACL systems from capability systems.
No Designation Without Authority (Property A): in an ocap system, to name a resource is already to have authority to use it; ACL systems decouple designation from authority, which is the root of confused-deputy problems.
Subject-Aggregated Authority Management (Property C): in ocap, you edit your own C-list; in ACLs, changing one authority requires editing a resource’s ACL.
Confinement is achievable via factories / constructors; KeyKOS and EROS are existence proofs.
Revocation by forwarders (facets): give Bob not Carol but a forwarder F; keep R as revoker; R !stopForwarding revokes Bob cleanly.
Object capabilities subsume Lampson while avoiding the ambient-authority pitfalls that produce confused deputies.

Connections

The Heart of Spritely - Distributed Objects and Capability Security
Capability Security - this paper is the canonical clarification of what capability security actually claims.
Object Capability Security - Model 4 in this paper is the object-capability model.
E Language - examples and diagrams use E-flavoured ocap reasoning.
CapTP - distributed ocap relies on the same non-myths.
Ambient Authority - the Equivalence Myth’s error is essentially failing to see ambient authority in ACL systems.
Confused Deputy - the paper leans on Hardy’s example to justify Property A.
Principle of Least Authority - POLA is called out as a motivation for preferring ocap.
Distributed Security
Security Kernel Lambda Calculus
Capability Revocation - Redell forwarders / facets are explained here.
Capability Bounding

Conceptual Contribution

Capability-based Financial Instruments

Reference

Miller, Mark S.; Morningstar, Chip; Frantz, Bill. “Capability-based Financial Instruments.” In Proceedings of the 4th International Conference on Financial Cryptography (FC 2000), Anguilla, BWI, February 20-24, 2000. LNCS 1962, pp. 349-378, Springer, 2001. URL

Summary

Also called the “Ode” paper (after its original filename ode.pdf), this paper bridges three previously disjoint communities: object-oriented programming, capability-based secure operating systems, and financial cryptography. The authors argue that each community has been strong where the others were weak - objects give composition and abstraction, capability OSs give mutually-protected shared platforms for untrusted code, and financial cryptography gives mutually-suspicious multiparty protocols - and that a unified abstraction, the Granovetter diagram, captures the core of all three.

The Granovetter diagram (named after sociologist Mark Granovetter’s work on how social topology evolves by introduction) shows three objects - Alice, Bob, Carol - where Alice holds references to both Bob and Carol and sends Bob a foo message containing her reference to Carol, thereby introducing Bob to Carol. This single operator is at once an object message send, a capability-security introduction (only connectivity begets connectivity), a cryptographic capability-transport step, an SPKI certificate-style authorisation delegation, a multi-player game-theoretic move, and the basic step for transferring a financial bearer right.

The paper presents the E programming language, its cryptographic transport protocol Pluribus (the predecessor of CapTP), and a worked example: a covered call option implemented in ~20 lines of E as a smart contract between five mutually-suspicious parties, implemented automatically as a cryptographic protocol. This is arguably the first paper to describe smart contracts in recognisably modern form, and it predates the blockchain era entirely. It is foundational for Agoric and for all later Miller work on eights/erights.

Key Ideas

Granovetter operator: the unit of object-capability computation - Alice holds refs to Bob and Carol; Alice sends Carol-ref to Bob; Bob now has Carol.
Only connectivity begets connectivity: authority can change only by this three-party introduction step.
Six perspectives on the Granovetter operator: object computation, capability security, cryptographic protocol, public-key infrastructure, multi-player game rule, financial bearer instrument.
Smart contracts as object code: a covered-call option is just an object with references to the underlying asset, the strike-price payment, and its counterparties.
Rights = sendable messages: a right is exercised by sending a message to an object that embodies it; secure transfer of a right = secure transfer of a reference.
Pluribus: E’s cryptographic capability transport, turning local object semantics into distributed multiparty protocols.
Bearer instruments classified along axes: exclusive/non-exclusive, fungible/specific, exercisable, assayable.

Connections

The Heart of Spritely - Distributed Objects and Capability Security - Spritely’s goblin/ocapN inherits the same Granovetter-diagram semantics.
E Language - this paper is the first major presentation of E to the financial-crypto world.
CapTP - Pluribus here is the direct predecessor of CapTP.
Capability Security and Object Capability Security
Ambient Authority - this paper is emphatic that ambient-authority systems cannot express financial rights safely.
Confused Deputy
Principle of Least Authority
Distributed Security
Security Kernel Lambda Calculus
A Universal Modular Actor Formalism for Artificial Intelligence
Actor Model
Vat Model
Promise Pipelining

Conceptual Contribution

EROS - A Fast Capability System

EROS: A Fast Capability System

Reference

Shapiro, Jonathan S.; Smith, Jonathan M.; Farber, David J. “EROS: A Fast Capability System.” In Proceedings of the 17th ACM Symposium on Operating Systems Principles (SOSP ’99), Kiawah Island, SC, December 1999. Published as ACM SIGOPS Operating Systems Review 34(5):170-185. URL

Summary

EROS (Extremely Reliable Operating System) is the third-generation reimplementation of the GNOSIS/KeyKOS capability architecture - the lineage created by Norm Hardy et al. at Tymshare in 1982 - clean-roomed in C++ for x86 by Jonathan Shapiro, Jonathan Smith, and David Farber at Penn. The paper’s central claim, surprising to many at the time, is that a pure capability microkernel with transparent single-level store persistence can match or beat conventional Unix-kernel operation costs on commodity hardware. The authors show this through detailed microbenchmarks and careful architectural choices.

Architecturally, EROS is a microkernel. All resources - processes, address spaces, nodes (32-capability arrays), pages, entry capabilities, resume capabilities - are named and manipulated by unforgeable capabilities enforced by a tagged in-kernel data structure. A protection domain is defined by the set of capabilities held. The performance story rests on three pillars: (1) aggressive caching of abstract objects (processes, nodes, pages) in representations chosen for the underlying hardware; (2) unified design of IPC and capability invocation so that cross-domain calls are cheap; and (3) orthogonal persistence via periodic consistent snapshots with copy-on-write - meaning EROS has no file system in the traditional sense: the single-level store is the persistence mechanism, transparent to applications. A machine crash resumes where it left off, modulo the checkpoint interval.

The paper also addresses mandatory access control, the KeySAFE design (user-level reference monitors inserted between compartments for DAC/MAC composition), and the architectural features (nodes, entry capabilities, resume capabilities for one-shot continuations) that together let EROS support confinement and fine-grained POLA. EROS directly inspires seL4, CapROS, Coyotos, and is the principal existence proof cited whenever someone claims capability systems must be slow. It is a central reference in Miller’s Robust Composition thesis and in the Capability Myths Demolished paper’s defeat of the Confinement Myth.

Key Ideas

Single-level store: no file system; persistence is transparent, implemented by periodic consistent copy-on-write snapshots.
Capability is an unforgeable (object-id, rights) pair, kernel-enforced via tagged storage.
Nodes: 32-slot capability arrays, the building block for address spaces (tree of nodes) and process state.
Entry / resume capabilities: first-class continuation-like capabilities for efficient IPC and one-shot reply.
Fast IPC: EROS capability invocation matches L4-class IPC, demonstrated by microbenchmarks.
KeySAFE compartments: user-level reference monitors mediate flow between compartments for policy insertion.
Confinement via factories / constructors: inherited from KeyKOS, demonstrably solves the confinement problem.
Performance is not a capability-system inherent cost: with the right abstractions and caching, ocap kernels match conventional kernels.

Connections

The Heart of Spritely - Distributed Objects and Capability Security - EROS is in the direct intellectual lineage Spritely draws on.
Capability Security, Object Capability Security - EROS is the flagship existence proof for practical capability OSs.
E Language - Miller’s thesis advisor is Shapiro; EROS and E are sister projects in Johns Hopkins’ SRL.
CapTP
Ambient Authority - EROS has essentially none; every action requires an explicit capability invocation.
Confused Deputy - EROS’s design makes confused-deputy scenarios expressible-as-bugs only by explicit negligence.
Principle of Least Authority - fine-grained node capabilities enable POLA at page level.
Distributed Security
Security Kernel Lambda Calculus
Capability Bounding
Capability Revocation

Conceptual Contribution

The Confused Deputy - Hardy

The Confused Deputy (or why capabilities might have been invented)

Reference

Hardy, Norm. “The Confused Deputy (or why capabilities might have been invented).” ACM SIGOPS Operating Systems Review, 22(4):36-38, October 1988. URL

Summary

Norm Hardy’s three-page note is the single most quoted security story in the capability tradition. It is a “nearly true” anecdote from roughly 1974 at Tymshare. A FORTRAN compiler, stored in directory SYSX, writes statistics to (SYSX)STAT and is therefore granted home files license - the ambient authority to write any file in SYSX. Users invoke the compiler as RUN (SYSX)FORT and may supply the name of a file in their own directory for optional debugging output. One day, a user passes (SYSX)BILL - the system billing file - as the output filename. The compiler, running with its SYSX authority, dutifully opens (SYSX)BILL for write and clobbers it. The billing data is lost.

Hardy walks through the standard reactions (blame the compiler, add a check for sensitive filenames, recategorise files, enumerate forbidden names) and shows that each misses the point. The compiler has been delegated authority it did not ask for and cannot distinguish: it cannot tell whether a request to write (SYSX)BILL comes from its own invariant need to write STAT (authority inherent to the compiler) or from the invoker’s request channel (authority inherent to the invoker). The compiler is acting as deputy for two different principals - itself and its invoker - with two different authorities, but the operating system gives it only one aggregated authority set with no way to trace which request justified which use.

The capability fix, Hardy explains, is to pass each authority as a capability at the point of need rather than to aggregate them ambiently on the compiler process. The invoker passes a capability to the output file; the compiler holds a separate capability to the statistics file; no ASCII pathname walk ever happens against an ambient authority. The Tymshare/KeyKOS team built KeyKOS on precisely this discipline. Hardy’s essay is the canonical demonstration of why ACL-plus-pathname operating systems have a structural bug (the confused deputy) that capability operating systems avoid by construction.

Key Ideas

Confused deputy: an authorised program manipulated by a less-authorised invoker into wielding its own greater authority on the invoker’s behalf.
Ambient authority is the underlying cause: the compiler’s SYSX home-files-license is in effect whenever the compiler runs, independent of which request is in flight.
Two principals, one process: the compiler serves its own goals and the invoker’s, with distinct authorities that the OS conflates.
Designation vs. authority: a filename in ACL systems is a pure designator; authority comes from who-is-running. In capability systems the capability is the designator-with-authority - no conflation possible.
Capabilities as the fix: present-tense authority via capability arguments eliminates the confusion.
KeyKOS is offered as the system built on precisely this discipline, with factories defeating Trojan horses and confined subsystems.

Connections

The Heart of Spritely - Distributed Objects and Capability Security
Confused Deputy - this note is Hardy’s original paper; Confused Deputy is the concept page.
Capability Security - Hardy’s “why capabilities might have been invented” is the operational motivation of the whole tradition.
Object Capability Security - object-capabilities inherit the fix directly.
E Language - E’s reference-passing discipline is an anti-confused-deputy design.
CapTP
Ambient Authority - Hardy is the source of the critique; ambient authority IS the bug.
Principle of Least Authority - the confused deputy appears when a process has more authority than the request demands.
Distributed Security
Security Kernel Lambda Calculus
Capability Bounding

Conceptual Contribution

Programming Semantics for Multiprogrammed Computations

Reference

Dennis, Jack B.; Van Horn, Earl C. “Programming Semantics for Multiprogrammed Computations.” Communications of the ACM, 9(3):143-155, March 1966. URL

Summary

The Dennis & Van Horn paper is the origin point of the capability concept in computer science. Written during the Project MAC era and responding to the needs of multiprogrammed, multi-user systems like MULTICS and the SABRE reservation system, it defines a set of meta-instructions that a supervisor provides to user programs to express the five core requirements of multiprogrammed computation: (1) parallel processing; (2) creating, suspending, and resuming computations; (3) protection of a computation from other computations; (4) debugging support; and (5) shared access to data and procedures.

The paper’s lasting contribution is the introduction of the capability (called a C-list entry) as the fundamental access-control primitive. A capability is an unforgeable pair of a unique-name (naming a segment or other object) and an access-indicator (X, R, RW, RWX) that determines what may be done with the object. A computation’s sphere of protection is defined precisely by its C-list. Crucially, a process cannot name a resource it has no capability for - designation and authority are unified. The paper introduces principals (the human or organisational accountability unit), processes as loci of execution, and the meta-instructions for fork/join, lock/unlock, I/O function invocation, and capability transfer.

This is the paper that every later capability system - Plessey 250, CAP, KeyKOS, EROS, seL4, E, Spritely - is ultimately paying tribute to. It is also striking how many apparently recent ideas (unforgeable references, segment-level fine-grained protection, per-process authority sets, mutually suspicious processes on one machine) are already present here in 1966.

Key Ideas

Capability as an unforgeable (unique-name, access-indicator) pair; the first definition in the literature.
C-list per process: the exhaustive list of a computation’s authorities.
Sphere of protection = closure of what a process can name and do via its C-list.
Principal vs process: accountability vs. execution.
Meta-instructions as the supervisor’s API for computations: fork, join, quit, lock, unlock, execute i/o function, create segment, enter block, etc.
Multiprogramming as access-control problem: protection, sharing, and scheduling are one design problem, not three.
Designation and authority unified: a name in a program is dereferenced through the C-list, so “unknown” resources are also “unreachable” - the ancestral seed of “no designation without authority.”
Mutually suspicious computations as a first-class goal.

Connections

The Heart of Spritely - Distributed Objects and Capability Security
Capability Security - this is the paper that invents the concept.
Object Capability Security - Miller-era ocap refines Dennis & Van Horn’s C-list into object references.
E Language - E’s reference-passing rules are a memory-safe OO realisation of Dennis-Van-Horn C-lists.
CapTP
Ambient Authority - designation-without-authority, which ambient-authority systems permit, is precisely what this paper eliminates by construction.
Confused Deputy - Hardy’s 1988 paper points back to Dennis & Van Horn as the road not taken.
Principle of Least Authority - C-lists make POLA expressible at segment granularity.
Distributed Security
Security Kernel Lambda Calculus
A Universal Modular Actor Formalism for Artificial Intelligence - Hewitt’s actors and Dennis-Van-Horn capabilities are parallel 1960s-70s answers to concurrent computation; Miller’s E later unifies them.
Actor Model
Vat Model

Conceptual Contribution

The Heart of Spritely - Distributed Objects and Capability Security

The Heart of Spritely: Distributed Objects and Capability Security

Reference: Christine Lemmer-Webber, Randy Farmer, Juliana Sims (2025). Spritely Institute whitepaper, May 21 2025. Source file: spritely-core.pdf. URL · Project

Summary

The second paper in Spritely’s three-part design series, this whitepaper lays out the technical core of Goblins — a distributed, transactional, object-programming environment built around object capability security (OCap). The thesis: secure peer-to-peer applications should feel like ordinary programming, not like a separate security discipline, and capability security makes that achievable. The operative slogan is “If you don’t have it, you can’t use it” — authority is conveyed only by holding a reference, never ambient.

The paper works through (1) capability security as ordinary reference-passing, motivated against Access Control Lists and the confused-deputy problem; (2) Goblins itself — a distributed object programming model with promise pipelining, vats as containers of synchronous turns, turns as cheap local transactions, and time-travel debugging; (3) OCapN — a new cross-implementation protocol for secure distributed object communication; (4) portable encrypted storage for capabilities; (5) library/application safety implications. Implementations exist for Guile and Racket Schemes, with a roadmap toward language-heterogeneous object invocation.

Goblins is the modern distillation of a three-decade lineage running through Mark Miller’s E language, the CapTP protocol, Jonathan Rees’s capability-kernel argument, and Carl Hewitt’s actor formalism. It reframes agent communication as object-reference passing over the network, offering an alternative substrate to the ACL/RPC-stack approach that dominates modern LLM-agent protocols.

Key Ideas

Principle of Least Authority (POLA): grant each piece of code only the authority it needs, no more
Object capability security: authority = unforgeable object reference. Lexical scoping + no ambient authority + no global mutable state
Confused-deputy problem: why ACLs fail when a privileged program is tricked into acting for an attacker
Vat: an isolated synchronous execution context; objects live inside vats; vats communicate asynchronously
Turn: an atomic event loop iteration inside a vat; turns are transactional — errors roll back the turn’s local state
Promise pipelining (from CapTP): chain calls on a reference before the prior call resolves, reducing round trips
Time-travel distributed debugging: replay turns deterministically across the network
OCapN (Object Capability Network): protocol for secure, cross-language distributed object invocation
Revocation and accountability as programmable patterns over references
“If you don’t have it, you can’t use it” — the design-level simplification capability security provides

Connections

Security Kernel Lambda Calculus — Rees’s lexical-scope-as-capability-kernel argument, directly cited
Capability Security
A Universal Modular Actor Formalism for Artificial Intelligence — vats descend from Hewitt actors
Actor Model
Programming Erlang Second Edition — sibling message-passing tradition
Communicating Sequential Processes — contrast in concurrency model
Agent Tcl Flexible Secure Mobile Agents — earlier capability-aware mobile agents
DAgents Security Book Chapter
Sandboxing
Distributed Security
LangSec
End-to-End Arguments in System Design — design-principle neighbour
Principled Design Of The Modern Web Architecture — architectural contrast (REST/ACL vs OCap)
Agent-to-Agent Protocol — OCapN is a capability-secure alternative
Model Context Protocol
Agent Network Protocol
Inter-Agent Trust Models - A Comparative Study — Constraint trust realised at the language level
Constraint Trust
MalTool Malicious Tool Attacks — OCap would structurally preclude many of these attacks
AI Agents Under Threat
ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems — the flat context trust model ClawWorm exploits is precisely what OCap eliminates
Flat Context Trust Model
Principle of Least Authority
Ambient Authority
Confused Deputy
Vat Model
Turn (Goblins)
Promise Pipelining
OCapN
CapTP
E Language
Time-Travel Debugging

Conceptual Contribution

Claim: Secure peer-to-peer applications become routine when authority is conveyed only by holding an unforgeable object reference — no ambient authority, no global mutable state, lexical scope as the capability kernel — and when the network distribution of such references is itself designed as an ordinary message-passing object system.
Mechanism: Goblins realises the E-language tradition in Scheme (Guile, Racket): objects live in vats; each vat runs atomic turns that serve as cheap local transactions; asynchronous inter-vat invocation uses promise pipelining to collapse round-trips; persistence, upgrade, and cross-language interop are handled by OCapN — a capability-preserving transport protocol. Time-travel debugging exploits the turn-level determinism.
Concepts introduced/used: Object Capability Security, Principle of Least Authority, Ambient Authority, Confused Deputy, Vat Model, Turn (Goblins), Promise Pipelining, OCapN, CapTP, E Language, Time-Travel Debugging, Capability Revocation
Stance: engineering / foundational design doc
Relates to: A modern engineering culmination of the capability-security thread rooted in Security Kernel Lambda Calculus (Rees 1995, explicitly cited) — lexical scope as a capability kernel, extended into a full distributed system. The vat model is a direct descendant of A Universal Modular Actor Formalism for Artificial Intelligence (Hewitt 1973) and sibling to Programming Erlang Second Edition but with security-by-reference as a first-class concern. Frames a structural alternative to the modern LLM-agent protocol stack: where Agent-to-Agent Protocol / Model Context Protocol / Agent Network Protocol layer trust on top of ACL/RPC primitives, OCapN encodes trust in the reference graph itself. The flat context trust model that ClawWorm Self-Propagating Attacks Across LLM Agent Ecosystems exploits and that MalTool Malicious Tool Attacks, AI Agents Under Threat catalogue is precisely the ambient-authority failure capability security is designed to prevent — making Goblins / OCapN a serious candidate substrate for Inter-Agent Trust Models - A Comparative Study’s Constraint trust dimension.

Can Programming Be Liberated from the von Neumann Style

Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs

Reference

Backus, J. (1978). “Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs.” 1977 ACM Turing Award Lecture. Communications of the ACM, 21(8), 613-641. URL

Summary

In his Turing Award lecture, Backus — the inventor of Fortran — delivers a startling self-critique of conventional programming languages. He argues that languages from Fortran through Algol to Pascal are all essentially von Neumann languages: they inherit the word-at-a-time, stored-program architecture’s assumptions (variables, assignment, statement sequencing, control flow through a single instruction pointer) and therefore suffer its bottlenecks. Programs written in this style are fat, inelegant, resist composition, and cannot be reasoned about algebraically because their meaning depends on an ever-changing hidden state.

As an alternative, Backus proposes FP — a functional programming language built from a small set of primitive functions and a handful of higher-order combining forms (composition, construction, condition, apply-to-all, insert). Programs are expressions that compose functions without mentioning variables or state. Crucially, FP comes equipped with an algebra of programs: equational laws that let one transform programs by substitution, exactly as one transforms algebraic expressions. A worked inner-product example shows the dramatic size and transparency gains: the FP version is a line of combinators; the Fortran version is a loop with state-manipulating assignments.

The lecture’s impact has been enduring and multifaceted. FP itself did not become mainstream, but its argument animated Haskell, ML, and the broader functional turn; its algebraic equations seeded Bird-Meertens “squiggol” formalism and the point-free programming style; its critique of the von Neumann bottleneck anticipated dataflow, array languages (APL/J/K), and GPU/SIMD programming. Backus’s central thesis — that programming needs a mathematical theory within which programs can be manipulated — is echoed in every modern effort to make software more composable, verifiable, and parallelizable.

Key Ideas

Von Neumann bottleneck: word-at-a-time traffic between CPU and store is inherited by conventional programming languages, making them conceptually as well as physically slow.
State and assignment as original sin: they block algebraic reasoning and force programmers to think like the machine.
FP (Functional Programming): a variable-free, point-free language of functions and combining forms.
Combining forms: composition, construction, condition, apply-to-all (map), insert (fold/reduce), while.
Algebra of programs: equational laws enabling syntactic program transformation and optimization.
Two kinds of functions: ordinary (first-order, operate on values) vs. combining forms (build new functions).
Program = expression: no statements, no mutable variables, no sequencing — just function composition.
Mathematical semantics: each program denotes a function; equivalence is extensional equality.

Connections

The Extensible Language - Graham
Code as Data
Recursive Functions of Symbolic Expressions and Their Computation by Machine — McCarthy’s LISP is the other founding functional work.
Algorithm = Logic + Control — Kowalski’s parallel argument for separating meaning from machinery.
A Universal Modular Actor Formalism for Artificial Intelligence — another push beyond stored-program orthodoxy.

Conceptual Contribution

Algorithm = Logic + Control

Reference

Kowalski, R. (1979). “Algorithm = Logic + Control.” Communications of the ACM, 22(7), 424-436. URL

Summary

Kowalski argues that every algorithm can be cleanly decomposed into two orthogonal components: a logic component, which specifies what knowledge is to be used to solve the problem, and a control component, which specifies how that knowledge is applied. The logic determines meaning and correctness; the control determines efficiency. The thesis is that programs become easier to write, to prove correct, and to optimize when these two concerns are separated and each is expressed explicitly — ideally, with the logic invariant under changes in control strategy.

Using Horn clauses as the logical language, Kowalski shows that a problem’s specification (e.g., “x is an ancestor of y”) can be written once and then executed under different control regimes — top-down (backward chaining, as in Prolog) or bottom-up (forward chaining, as in database query evaluation) — without changing the logic. Different strategies produce different computational costs, but all produce the same answers because the meaning is governed by the logic alone. He illustrates with factorial, sorting, and path-finding, and crucially with Horn-clause definitions of recursive relations where choice of control dramatically affects termination and performance.

The paper is the manifesto of logic programming. It frames Prolog not as “predicate logic with a goto button” but as one control discipline over a logical program; it underwrites deductive databases, constraint logic programming, tabled evaluation, and answer-set programming; and it anticipates the modern separation of declarative specification from execution plan found in SQL optimizers, datalog engines, and differentiable programming. The slogan “A = L + C” remains a litmus test: a program whose logic and control are tangled is harder to understand than one where they are kept apart.

Key Ideas

A = L + C: an algorithm has a logic component (meaning) and a control component (execution strategy).
Logic determines correctness; control determines efficiency: change control without changing meaning.
Horn clauses: clausal form of predicate logic sufficient for programming, with tractable inference.
Top-down vs bottom-up: backward-chaining (SLD resolution / Prolog) and forward-chaining (datalog / bottom-up) as control choices.
Declarative programming: say what is true; let a general-purpose inference mechanism search for solutions.
Separation of concerns: specifications, programs, and query plans all viewable through the same lens.
Clausal refutation: problems stated as denials, solved by deriving contradiction, answer extracted from substitutions.

Connections

Foundations of Logic Programming - Lloyd — Lloyd’s book formalizes the semantics Kowalski sketches.
Logicist AI
Horn Clauses
A Universal Modular Actor Formalism for Artificial Intelligence — PLANNER had a similar logic/control split that Kowalski clarifies.
Code as Data — logic programs are homoiconic data usable by other programs.

Conceptual Contribution

Mechanism Design

The branch of game theory that designs interaction rules so that self-interested agents, acting in equilibrium, produce a desired social outcome; applied in ACL evolution to shape negotiation protocols that reach efficient linguistic conventions.

In this vault

Toward Automated Evolution of ACLs

Second-Price Auction

Synonym for Vickrey Auction. The pricing rule — winner pays the second-highest bid — is what makes truth-telling a dominant strategy: the price the winner pays is the externality they impose on losing bidders, aligning private incentive with social efficiency.

In this vault

Vickrey Auction

The sealed-bid second-price auction proposed by Vickrey (1961): each bidder submits a sealed bid; the highest bidder wins but pays the second-highest bid. Truth-telling is a dominant strategy — bidding one’s true valuation is weakly optimal against any opponent strategy. The canonical truthful / strategy-proof mechanism; foundational for Mechanism Design and the Vickrey-Clarke-Groves family of multi-item generalisations.

In this vault

Counterspeculation Auctions and Competitive Sealed Tenders

Counterspeculation, Auctions, and Competitive Sealed Tenders

Reference: Vickrey, W. (1961). Counterspeculation, Auctions, and Competitive Sealed Tenders. The Journal of Finance, 16(1), pp. 8–37. DOI · Open access PDF (Princeton)

Summary

Vickrey provides the first systematic game-theoretic analysis of auction formats and proves the result that established the field of mechanism design: in a sealed-bid second-price auction (now called the Vickrey auction), the dominant strategy for each bidder is to bid their true valuation. The proof is short and constructive: bidding above one’s value risks winning at a loss; bidding below risks losing an item one would have profitably won; bidding exactly one’s value is weakly better than any other bid against any opponent strategy. The auction is therefore strategy-proof: bidders need not engage in counter-speculation about what other bidders will do, because their best response is independent of the other bidders’ strategies. Vickrey also analyses the four classical auction formats — English (ascending open-cry), Dutch (descending open-cry), first-price sealed-bid, second-price sealed-bid — proves the revenue equivalence of English and second-price (with rational bidders), and the corresponding equivalence of Dutch and first-price. The paper inaugurates mechanism design as the formal study of how to construct strategic interactions whose equilibria yield desired outcomes — in particular, truth-telling equilibria. Vickrey won the 1996 Nobel Prize for this and related work; the Vickrey-Clarke-Groves (VCG) family generalises the second-price auction to multi-item and combinatorial settings, and underpins almost all sponsored-search auctions, spectrum auctions, and modern auction-based resource allocation. For multi-agent systems, Vickrey is the canonical truthful mechanism: a setup in which agents need not strategise about each other to play optimally, eliminating the regress of theory-of-mind reasoning that Pact-style choreographies otherwise require.

Key Ideas

Sealed-bid second-price auction: each bidder submits a sealed bid; the highest bidder wins but pays the second-highest bid (the highest losing bid). The pricing rule is the key innovation.
Truth-telling is a dominant strategy: bidding one’s true valuation v_i is weakly optimal against every opponent strategy. Bidding above risks paying more than v_i; bidding below risks losing an item worth more than the price one would have paid. Independent of opponents’ beliefs and strategies.
Strategy-proofness as a design property: a mechanism is strategy-proof iff truth-telling is a dominant strategy for all participants. Strategy-proof mechanisms eliminate the counterspeculation burden — agents need not model each other.
Revenue equivalence (special case): English and second-price auctions yield the same expected revenue with rational bidders; Dutch and first-price likewise. (The full Revenue Equivalence Theorem, due to Myerson 1981 and others, generalises far beyond these four.)
Inefficiency of first-price auctions: in first-price sealed-bid, bidders shade their bids below true valuation by an amount that depends on beliefs about other bidders — strategic, but not necessarily efficient. The second-price design eliminates this distortion.
Foundations of mechanism design: the paper establishes the conceptual programme of designing games whose equilibria yield socially desirable outcomes, with truth-telling as one canonical objective. VCG (Clarke 1971, Groves 1973) generalises second-price to multi-item and combinatorial settings using the same incentive principle.
Why second-price works: the price a winner pays is the externality they impose on the rest of the bidders — the value the next-best bidder would have obtained had the winner not been there. Aligning private cost with social externality drives truthful behaviour.

Connections

Conceptual Contribution

Claim: A sealed-bid auction in which the winner pays the second-highest bid makes truth-telling a dominant strategy for every bidder. Mechanism designers can therefore construct auctions in which agents need not strategise about each other to play optimally — the counterspeculation burden is eliminated. This launches the formal study of mechanism design: constructing games whose equilibria yield desired outcomes.
Mechanism: Sealed-bid auction with second-price pricing; explicit dominance argument for truthful bidding; comparison of English / Dutch / first-price sealed-bid / second-price sealed-bid auctions; establishment of revenue equivalence between English and second-price; analysis of bid-shading in first-price auctions.
Concepts introduced/used: Vickrey Auction, Second-Price Auction, Truthful Mechanism, Strategy-Proof, Counterspeculation, Mechanism Design, Revenue Equivalence, Externality-aligned pricing.
Stance: foundational technical paper (Nobel-Prize-winning).
Relates to: Foundational paper for the entire field of Mechanism Design (Hurwicz, Maskin, Myerson, Roth — five Nobel Prizes between them); the Vickrey-Clarke-Groves family (Clarke 1971, Groves 1973) generalises second-price to combinatorial and multi-item settings and is the analytical core of all major sponsored-search and spectrum auctions. In MAS, Vickrey auctions appear as the canonical truthful resource-allocation mechanism — used in agent-based market designs since the 1980s, in cloud-computing resource auctions, and in academic LLM-agent negotiation testbeds. Conceptually, the strategy-proofness property eliminates the theory-of-mind regress that motivates Pact’s level-ℓ bounded-rational solver: when the mechanism is strategy-proof, bidders’ best moves do not depend on their beliefs about others, so the recursion collapses to depth 1. This is one of the strongest design principles for agent-coordination protocols: prefer mechanisms in which truth-telling is a dominant strategy over mechanisms requiring strategic reasoning. Vickrey’s analysis of revenue equivalence also frames the larger trade-off in protocol design between individual rationality (each agent prefers participating to not) and efficiency (the mechanism produces a socially-optimal allocation) — the same trade-off Deals Among Rational Agents (Rosenschein & Genesereth 1985) takes up for general multi-agent deal-making.

Tags

#mechanism-design #vickrey #auctions #truthful-mechanism #strategy-proof #game-theory #foundations

Reciprocity

The principle of returning like for like: cooperation for cooperation, defection for defection. The mechanism behind Tit-for-Tat’s success in IPD play and behind much of human social cooperation (Trivers 1971 Reciprocal Altruism; Fehr & Gächter 2002 Strong Reciprocity). In MAS, reciprocity is the operative principle of most computational trust models — agents track partners’ past behaviour and modulate cooperation accordingly. The information conditions for reciprocity to support cooperation (recognition of partners across rounds, memory of past interactions, sufficient shadow of the future) are non-trivial design constraints for any open multi-agent system.

In this vault

Tit-for-Tat

The strategy that won both of Axelrod’s (1979, 1980) iterated-prisoner’s-dilemma tournaments: cooperate on the first move, then on each subsequent move copy the opponent’s previous move. Four lines of code, submitted by Anatol Rapoport. Demonstrates that successful IPD play does not require sophistication; it requires being nice (never defect first), retaliating (punish defection promptly), forgiving (return to cooperation as soon as the opponent does), and clear (predictable enough for opponents to learn cooperation with you). Foundational for trust-and-reputation models in MAS.

In this vault

Iterated Prisoners Dilemma

The repeated version of the classical prisoner’s dilemma game: each round, both players choose cooperate or defect, with payoffs T > R > P > S (temptation > reward > punishment > sucker), and play continues for an indefinite number of rounds with discount factor w. Unlike the one-shot game (where defection is dominant), iterated play with sufficient w makes cooperation rationally sustainable via reciprocal strategies like Tit-for-Tat. The standard testbed for cooperative MAS / cooperative-AI research, made canonical by Axelrod’s tournaments (1979–1984).

In this vault

The Evolution of Cooperation

Reference: Axelrod, R. (1984). The Evolution of Cooperation. Basic Books, New York. (Revised 2006 with new afterword by Axelrod and a foreword by Richard Dawkins. Underlying conference papers: Axelrod, R. & Hamilton, W. D. (1981). The Evolution of Cooperation. Science 211(4489), pp. 1390–1396.) Science 1981 DOI · Internet Archive borrow (book)

Summary

Axelrod investigates how cooperation can arise and persist among self-interested agents in the absence of central authority — by running computer tournaments of strategies for the iterated prisoner’s dilemma (IPD). In the one-shot prisoner’s dilemma, defection is the dominant strategy and rational play leads both parties to a Pareto-inferior outcome. Axelrod’s central question is whether iteration changes the picture. He invited game theorists to submit strategies; in two tournaments (1979 and 1980, the second much larger and including strategies designed to exploit the first round’s lessons) tit-for-tat — submitted by Anatol Rapoport, only four lines of code (cooperate on the first move, then copy the opponent’s previous move) — won both. The book’s analytic contribution is identifying why. Axelrod isolates four properties of successful IPD strategies: niceness (never defect first), retaliation (punish defection promptly), forgiveness (return to cooperation as soon as the opponent does), and clarity (be predictable so the opponent can learn to cooperate with you). He proves an evolutionary-stability result: a population of tit-for-tat players cannot be invaded by any non-cooperative strategy if the discount factor (probability of further interaction) is sufficiently high. The book extends the analysis to historical case studies — most famously the live-and-let-live system in WWI trench warfare — and to biological evolution of cooperation in symbiosis and group selection. Axelrod’s framework supplies the foundation for mechanism-design approaches to multi-agent cooperation, the theoretical underpinning of trust-and-reputation systems, and the contemporary literature on cooperative AI.

Key Ideas

Iterated prisoner’s dilemma changes everything: in repeated play with sufficient probability of further interaction, cooperation is rationally sustainable; the shadow of the future makes defection costly.
Tit-for-tat wins both tournaments: the simple strategy of cooperating first, then copying the opponent’s previous move, beats much more sophisticated strategies because it is nice (avoids unprovoked defection), retaliatory (punishes promptly), forgiving (returns to cooperation immediately), and clear (transparent enough that opponents can learn to cooperate).
Four properties of successful strategies: nice (never defect first), retaliating (defect immediately if opponent defects), forgiving (cooperate again as soon as opponent does), clear (recognisable as a tit-for-tat-like strategy).
Evolutionary stability: a population of tit-for-tat players resists invasion by non-cooperative mutants when the discount factor w is high enough (w > (T - R) / (T - P) for the standard payoffs). Cooperation is an evolutionary attractor, not just an analytical curiosity.
Cluster invasion: a small cluster of tit-for-tat players in a sea of all-defect can invade the population if the cluster is large enough that within-cluster interactions dominate cross-cluster interactions — explaining how cooperation can emerge from a non-cooperative starting point.
Trench warfare in WWI: extensive case study of how live-and-let-live systems emerged in static trench positions where the same units faced each other repeatedly — a real-world iterated prisoner’s dilemma in which tit-for-tat-like strategies emerged spontaneously and were eventually suppressed only by the introduction of artillery and unit rotation that reduced the “shadow of the future.”
Recommendations for promoting cooperation: enlarge the shadow of the future (longer-term relationships, more frequent interactions), change the payoffs (reduce the temptation to defect), teach reciprocity, improve recognition (allow opponents to remember each other), enhance retaliation capabilities.

Connections

Conceptual Contribution

Claim: Cooperation among self-interested agents arises and persists in the absence of central authority when interactions are iterated with sufficient probability of further interaction. The successful strategies are nice, retaliating, forgiving, and clear; tit-for-tat is the simplest example. A population of tit-for-tat players is evolutionarily stable; small clusters of cooperators can invade non-cooperative populations.
Mechanism: Two open computer tournaments of IPD strategies; analysis of why tit-for-tat won; isolation of the four properties of successful strategies; evolutionary-stability and cluster-invasion theorems with explicit conditions on the discount factor; case studies (WWI trenches, biological symbiosis); concrete recommendations for institutional design.
Concepts introduced/used: Iterated Prisoners Dilemma, Tit-for-Tat, Reciprocity, Shadow of the Future, Niceness/Retaliation/Forgiveness/Clarity, Evolutionary Stability (in IPD), Cluster Invasion.
Stance: foundational research monograph in cooperative game theory and behavioural economics.
Relates to: Foundational for the trust-and-reputation programme in MAS — Review on Computational Trust and Reputation Models and Inter-Agent Trust Models - A Comparative Study systematise the engineering descendants of Axelrod’s tit-for-tat-with-memory across dozens of computational trust models. Conceptual companion of Lewis (1969) and Schelling (1960) in establishing how cooperation/coordination arise without central authority — the three together supply the standard reading list for emergent-cooperation work in MAS. In the LLM-agent era, the IPD setting is the standard testbed for evaluating cooperative AI; the four properties (nice/retaliating/forgiving/clear) translate directly into design criteria for multi-agent LLM coordination protocols, and the clarity property is particularly relevant to the Why AI Agents Communicate In Human Language critique — natural-language strategies are hard to recognise as tit-for-tat-like, so the cooperation-supporting mechanisms Axelrod identified are weakened. The Cooperative AI research programme (Dafoe et al. 2020) is an explicit modern continuation of Axelrod’s project for the multi-agent LLM era.

Tags

#game-theory #cooperation #axelrod #iterated-prisoners-dilemma #tit-for-tat #reciprocity #foundations #trust

Schelling Point

Synonym for Focal Point — the salient equilibrium parties converge on in a coordination game with multiple equilibria, named after Thomas Schelling who introduced the concept in The Strategy of Conflict (1960).

In this vault

Focal Point

Schelling’s (1960) concept: in a coordination game with multiple equilibria, the equilibrium parties converge on by virtue of salience — some feature that “stands out” in their shared informational and cultural background, distinguishing it from the others. Salience is not derivable from the payoff structure alone — it depends on context, prominence, simplicity, history. The cognitive mechanism by which Lewis-style conventions emerge without explicit agreement.

In this vault

The Strategy of Conflict

Reference: Schelling, T. C. (1960). The Strategy of Conflict. Harvard University Press, Cambridge MA. (Reprinted 1980 with new preface.) Harvard UP page · Internet Archive borrow (book; no full-text OA.)

Summary

Schelling reframes game theory as the theory of strategic interdependence — the analysis of decision-making in situations where each party’s best move depends on what they expect the others to do, including in situations of mixed conflict and cooperation. The book opposes the prevailing post-von-Neumann emphasis on zero-sum games and pure conflict; Schelling’s central observation is that almost all real strategic situations have both conflict and cooperation elements, and the interesting analytic work is in the cooperation-within-conflict structure. The book’s most enduring concept is the focal point (or Schelling point): in a coordination problem with multiple equilibria, parties converge on the equilibrium that is salient — distinguished by some feature that “stands out” in the shared cultural / informational background. Schelling demonstrated this experimentally: subjects asked to meet a stranger in New York City on a particular day, with no prior communication, overwhelmingly converged on Grand Central Terminal at noon. There is no equilibrium-selection argument in classical game theory that picks Grand Central; saliency does. Other lasting contributions include the analysis of credible commitment (binding oneself in advance can be a strategic asset, not a constraint); the concept of the threat that leaves something to chance; precommitment via burning bridges; tacit bargaining; and an early treatment of arms-race dynamics. The book inaugurated the modern study of bargaining, conflict resolution, and coordination — and won Schelling the 2005 Nobel Prize in Economics. For agent communication, the central inheritance is the focal-point concept: when explicit communication is impossible or noisy, agents coordinate on salient features of their shared situation. Lewis’s Convention (1969) is its philosophical companion.

Key Ideas

Strategy is interdependent decision: the right object of study is the situation in which each party’s payoff depends on others’ actions, not the isolated decision-theoretic agent.
Mixed-motive games: real conflicts almost always combine conflicting and shared interests; pure-conflict zero-sum games are a degenerate special case.
Focal points / Schelling points: in coordination problems with multiple equilibria, parties converge on the equilibrium that is salient in the shared informational and cultural background. Salience is not derivable from the payoff structure alone — it depends on context, history, prominence, simplicity.
Credible commitment as strategic asset: a party that can publicly bind itself in advance often does better than one with full strategic flexibility, because the binding rules out outcomes the other party would prefer to avoid. Burning bridges, hostage-taking, automatic-response systems, and unilateral declarations are concrete devices.
The threat that leaves something to chance: an irrevocably probabilistic threat (a “doomsday machine” with random triggering, a brinksmanship strategy) can credibly deter when a deterministic threat could not — because the threatener does not control whether it will be carried out.
Tacit bargaining: parties can coordinate on outcomes without explicit communication by relying on shared salience and convention.
Arms-race stability vs instability: Schelling distinguishes situations in which arms accumulation reduces incentives to strike first (stabilising) from those in which it increases them (destabilising) — the foundational analysis behind nuclear deterrence theory.

Connections

Conceptual Contribution

Claim: Strategy is the analysis of interdependent decision-making in mixed-motive (conflict + cooperation) situations; the right concepts include credible commitment, focal-point convergence under saliency, the threat that leaves something to chance, and tacit bargaining. These are not derivable from classical zero-sum game theory.
Mechanism: Reframing of game theory as theory of strategic interdependence; experimental and conceptual demonstrations of focal-point coordination; analysis of commitment devices and probabilistic threats; case studies in industrial bargaining, nuclear deterrence, racial integration, and traffic.
Concepts introduced/used: Focal Point, Schelling Point, Tacit Coordination, Credible Commitment, Threat Leaving Something to Chance, Mixed-Motive Game.
Stance: foundational research monograph (Nobel-Prize-winning).
Relates to: Direct philosophical and analytical companion to Lewis 1969 — both treat the equilibrium-selection problem in coordination games, with Lewis emphasising the social-philosophical structure of mutual expectation and Schelling emphasising the cognitive structure of saliency. The two together supply the foundation for every analysis of how shared meaning, currency, social roles, and (now) ACL semantics arise without explicit agreement. In MAS, the focal-point concept underlies role assignment without communication, emergent coordination conventions in ad-hoc teamwork, and the whole study of zero-shot coordination in MARL. In the ACL evolution programme (Toward Automated Evolution of ACLs, Towards Automating the Evolution of Linguistic Competence), focal points appear implicitly as the salient features that drive lexicon convergence. In LLM-agent settings, focal-point reasoning is one of the principal mechanisms by which agents coordinate without protocols — and a primary attack surface, since what is salient to an LLM is shaped by training data in adversarially exploitable ways.

Tags

#game-theory #schelling #focal-points #coordination #bargaining #foundations #credible-commitment

Commitment Store

Hamblin’s (1970) and Walton & Krabbe’s (1995) foundational construct: each participant in a dialogue has a public set of propositions to which they are committed, updated by their utterances under the dialogue’s rules. Statements add to one’s store; concessions add to the store of the participant who concedes; retractions (under restricted conditions) remove. The commitment store is the operational basis of Public Semantics / Commitment-based Semantics in ACLs — Singh’s, Fornara & Colombetti’s, and Yolum & Singh’s commitment-machine programmes all instantiate the Hamblin commitment-store concept in agent-communication-language form.

In this vault

Fallacies - Hamblin

Fallacies

Reference: Hamblin, C. L. (1970). Fallacies. Methuen, London. (Reprinted 1986 by Vale Press; reissued 2022 by University Press of America.) Google Books preview · McMaster summary (book; no full-text OA.)

Summary

Hamblin’s Fallacies is the founding text of the modern revival of formal dialectic. The book has two halves. The first is a magisterial historical and critical survey demolishing what Hamblin calls the Standard Treatment: the lazy textbook tradition of cataloguing fallacies as freestanding logical errors, traceable to a misreading of Aristotle that has propagated unchanged through two thousand years of logic textbooks. Hamblin shows that almost every “fallacy” in the standard inventory either is not actually fallacious in context, is fallacious for reasons orthogonal to those typically given, or is incoherent as classified. The second half supplies a constructive alternative: a formal dialectical treatment in which arguments are evaluated not in isolation but as moves within rule-governed dialogues. The technical centrepiece is the commitment store: each participant in a dialogue has a public set of propositions to which they have committed, updated by their dialogue moves under explicit rules (statements add commitments, “Why?”-challenges may force retraction or defence, concessions add to the conceder’s store, and so on). A move is fallacious iff it violates the rules of the dialogue type — a context-relative notion that finally distinguishes (e.g.) when petitio principii is genuinely circular reasoning and when it is licit appeal to shared ground. The book inaugurated the dialectical tradition that runs through Walton & Krabbe 1995, Mackenzie, Pollock, and the entire computational-argumentation field; the commitment-store concept is the operational ancestor of every commitment-based ACL semantics.

Key Ideas

The Standard Treatment is incoherent: the textbook list of fallacies (begging the question, ad hominem, ad baculum, equivocation, …) cannot be analysed at the level of individual arguments because what counts as fallacious depends on the dialogue context and the participants’ shared and individual commitments.
Arguments live in dialogues: an argument is a move in a structured exchange; its assessment requires the dialogue’s rules — what are the legal moves, what does each move oblige one to defend, what counts as winning?
Commitment store as the engine: each participant’s public commitment set is updated by their moves; the dialogue’s rules govern what one is licensed to say given the current state of one’s own and others’ stores.
Why-because-question games: Hamblin gives explicit toy dialogue systems (variants of the “H system”) in which moves are Statement, Question, Challenge, Retract, Resolve and the rules govern what each licenses or requires.
Fallacies as dialogue-rule violations: petitio principii becomes the move of trying to use as a premise something the opponent has not yet committed to (or has explicitly challenged); ad hominem becomes the illicit shift from a persuasion to a personal-attack dialogue; etc.
Recovery of Aristotle: Hamblin’s reading of Aristotle’s Sophistical Refutations shows that the original treatment was already dialectical — it was the medieval and modern textbook tradition that flattened it into a list of logical errors.
The book’s lasting move: not a particular dialogue system but the programme of taking dialogue as the primary unit of analysis, which Walton & Krabbe (1995) and the computational-argumentation literature (Prakken, Vreeswijk, McBurney, Parsons) made operational.

Connections

Conceptual Contribution

Claim: Fallacies cannot be analysed as defects of single arguments; they are violations of the rules of the dialogue type within which the argument is offered. The right unit of analysis is the dialogue, with explicit rules governing each participant’s commitment store and the legitimate moves that update it.
Mechanism: Critical demolition of the Standard Treatment via close textual reading from Aristotle through 19th-century logic textbooks; constructive presentation of toy dialogue systems (the “H system” and variants) with explicit move-rules and commitment-store updates; reanalysis of canonical fallacies as type-specific rule violations.
Concepts introduced/used: Commitment Store, Formal Dialectic, Dialogue Move, Why-Statement-Resolve game, petitio principii qua dialectical fault, Standard Treatment.
Stance: founding theoretical monograph of modern dialectic.
Relates to: Direct ancestor of Commitment in Dialogue (Walton & Krabbe 1995), which extends Hamblin’s commitment-store machinery into a six-type dialogue typology and supplies the framework that the ACL commitment-based semantics tradition takes as given. The commitment-store concept is the operational primitive of Singh’s critique of mentalistic ACL semantics: where KQML / FIPA-ACL ground meaning in private mental states, Singh grounds it in public commitments — a direct lift of Hamblin into multi-agent communication. The dialectical-rules approach is also the upstream ancestor of structured argumentation systems (ASPIC+, ABA, DeLP) that instantiate Dung’s abstract framework with rule languages, and of dialogue-game protocol specifications (Coordinating Agents Using ACL Conversations, ACRE Agent Conversation Reasoning Engine). On the LLM-agent side, Hamblin’s central insight — that the fallaciousness of a move depends on the dialogue type and rules — is precisely the diagnostic missing from most LLM-agent debate / self-consistency setups: there is no commitment store, no dialogue type, and so no principled way to identify illegitimate moves.

Tags

#dialogue #formal-dialectic #commitment-stores #fallacies #foundations #hamblin #pragmatics

Dialogue Typology

Walton & Krabbe’s (1995) classification of argumentative dialogue into six basic types: persuasion (resolve a conflict of opinion), negotiation (resolve a conflict of interest), deliberation (decide on a course of action), inquiry (prove a hypothesis), information-seeking (transfer of information from informed to uninformed), eristic (vent emotion). Each is characterised by initial situation × individual goals × shared goal. Real argumentation often shifts between types — licit shifts broaden the dialogue, illicit ones constitute fallacies.

In this vault

Commitment in Dialogue

Commitment in Dialogue: Basic Concepts of Interpersonal Reasoning

Reference: Walton, D. N. & Krabbe, E. C. W. (1995). Commitment in Dialogue: Basic Concepts of Interpersonal Reasoning. SUNY Series in Logic and Language. State University of New York Press, Albany. Internet Archive borrow (book; institutional access via SUNY.)

Summary

Walton and Krabbe synthesise two decades of work on formal dialectic (Hamblin 1970 onward) and informal logic into a typology of dialogue and a corresponding theory of how participants’ commitments evolve as a dialogue proceeds. Their central observation is that argumentation in natural settings is not a single uniform activity but a structured family of dialogue types, each characterised by its initial situation, the individual goals of the participants, and the shared goal of the dialogue. The six basic types they identify — persuasion, negotiation, deliberation, inquiry, information-seeking, eristic — are mutually distinguished by these three dimensions and by their characteristic legitimate moves. Across all types, every utterance updates each participant’s commitment store: the public set of propositions to which they have committed, are committed by inference, and may be challenged on. The book gives semi-formal rules for each dialogue type, analyses dialogue shifts (moves that licitly or illicitly transition between dialogue types — e.g. a persuasion shifting to a negotiation), and uses the framework to give principled accounts of fallacies as illegitimate dialogue moves rather than logical errors. Its influence on multi-agent systems is enormous: every commitment-based ACL semantics (Singh, Fornara & Colombetti) inherits the Hamblin/Walton commitment-store concept; protocol-design work (e.g. ACRE, An Interaction-oriented Agent Framework for Open Environments) uses dialogue-type analysis to specify legitimate conversation policies.

Key Ideas

Six basic dialogue types: persuasion (resolve a conflict of opinion), negotiation (resolve a conflict of interest), deliberation (decide on a course of action), inquiry (establish proof of a hypothesis from agreed premises), information-seeking (transfer of information from informed to uninformed), eristic (vent emotion / display superiority). Each is characterised by initial situation × individual goals × shared goal.
Commitment store as the engine of dialogue: every participant has a public set of commitments updated by their moves; speech acts add, retract, or qualify entries. The store is open to challenge by other participants under the dialogue’s rules.
Dialectical / propositional commitments: Walton & Krabbe distinguish explicit commitments (asserted propositions) from inferred commitments (entailed by, or presupposed by, what was said) — a distinction crucial for capturing implicit communication.
Dialogue shifts: most real argumentation moves between dialogue types. Some shifts are licit (a persuasion may legitimately broaden into a deliberation); others are illicit (an information-seeking dialogue exploited as a covert persuasion is a fallacy of digression).
Fallacies as dialogue-rule violations: rather than treating fallacies as defects of single arguments (the syllogistic tradition), they are analysed as moves that violate the rules of the dialogue type they occur in — a circular argument is fine in inquiry but fallacious in persuasion.
Profiles of dialogue: a sequence diagram of typical turns within a dialogue type — the precursor of Conversation Policy / interaction-protocol diagrams in the ACL literature.

Connections

Conceptual Contribution

Claim: Argumentation is not a single uniform activity but a structured family of dialogue types characterised by the participants’ goals; within each type, every utterance updates each participant’s public commitment store under type-specific rules; fallacies are best analysed as illegitimate dialogue moves rather than as defective arguments.
Mechanism: Six basic dialogue types defined by initial situation × individual goals × shared goal; dialogue rules per type; commitment-store update semantics; analysis of dialogue shifts and mixed dialogues; classification of fallacies as type-specific rule violations.
Concepts introduced/used: Dialogue Typology, Commitment Store, Persuasion Dialogue, Deliberation Dialogue, Inquiry Dialogue, Information-Seeking Dialogue, Eristic Dialogue, Negotiation, Dialogue Shift, Profile of Dialogue.
Stance: synthesis monograph / theoretical framework.
Relates to: Provides the upstream typology that the commitment-based ACL programme (Singh, Fornara & Colombetti, Commitment Machines - Yolum and Singh) takes as given when it makes commitments first-class. The Hamblin commitment-store mechanism (Fallacies - Hamblin) is the operational heart; Walton & Krabbe extend it with the dialogue-type framing. Conceptually adjacent to Grice’s cooperative principle but more granular: where Grice supplies a single cooperative norm, Walton & Krabbe show that the relevant cooperation is type-specific (persuasion ≠ negotiation ≠ inquiry). Coordinating Agents Using ACL Conversations (Cost et al.) and ACRE Agent Conversation Reasoning Engine are direct engineering descendants — Coloured Petri Nets and Dooley graphs are formal specifications of the kinds of dialogue Walton & Krabbe describe semi-formally. In the LLM-agent era the dialogue-type taxonomy is the obvious diagnostic for MAST-style failures (e.g. multi-agent systems unwittingly conducting eristic dialogues at scale, or persuasion-shifts hijacking deliberations) and a natural specification language for conversation-policy enforcement.

Tags

#dialogue #argumentation #commitment-stores #foundations #walton #krabbe #pragmatics #acl-foundations

Argumentation Framework

Dung’s (1995) abstraction: a directed graph (A, R) whose nodes are arguments and whose edges R ⊆ A × A are attacks. The semantics is content-free — what an argument is is supplied by the instantiating theory — but the family of extensions (Admissible Set, Grounded Extension, Preferred Extension, Stable Extension, complete) is universal. The substrate for ASPIC+, ABA, DeLP, multi-agent dialogue protocols, legal reasoning systems, and (recently) LLM-agent debate.

In this vault

On the Acceptability of Arguments

On the Acceptability of Arguments and its Fundamental Role in Nonmonotonic Reasoning, Logic Programming, and n-Person Games

Reference: Dung, P. M. (1995). On the Acceptability of Arguments and its Fundamental Role in Nonmonotonic Reasoning, Logic Programming and n-Person Games. Artificial Intelligence, 77(2), pp. 321–357. DOI · Open access PDF (CUNY)

Summary

Dung shows that an enormous span of problems in AI — nonmonotonic reasoning, logic programming, n-person game theory — share a single underlying abstraction: a directed graph whose nodes are arguments and whose edges are attacks. He calls this an abstract argumentation framework (AF) and develops, in 30 pages, the entire theory of argument acceptability that has dominated computational argumentation ever since. The headline definitions: a set of arguments is conflict-free if it contains no attacker-attackee pair; admissible if it is conflict-free and defends each of its members against every attacker (an argument is defended if every attacker on it is itself attacked by something in the set); complete if it is admissible and contains every argument it defends; grounded (the unique smallest complete extension), preferred (a maximal admissible set), stable (admissible and attacks every argument outside it). Dung then proves the unifying results: the stable extensions of an AF coincide with the stable models of the corresponding logic program (Gelfond–Lifschitz); preferred extensions correspond to the preferred logic-programming semantics; default-logic extensions arise as stable extensions of an AF derived from default rules; and (the n-person game result) the stable extensions of a game’s argumentation graph correspond to the stable strategies of the game. The framework is content-agnostic — what an “argument” is is left to the instantiating theory — which is precisely what makes it apply across so many domains. Three decades later it is the substrate for legal reasoning systems, multi-agent dialogue protocols, structured argumentation calculi (ASPIC+, ABA, DeLP), and the theoretical underpinning of LLM-agent debate frameworks.

Key Ideas

Argument as a black box, attack as a binary relation: the AF (A, R) with A a set of arguments and R ⊆ A × A is the entire syntactic apparatus. All domain-specific structure (premises, conclusions, defeasible rules) is internalised when the AF is instantiated.
Defence as the operative concept: an argument a is defended by a set S iff every attacker of a is itself attacked by some member of S. Acceptability is “S defends every member of S.”
Family of extensions: admissible (defends itself), complete (admissible + closure), grounded (least complete — sceptical), preferred (maximal admissible — credulous), stable (admissible + attacks everything outside).
Universal correspondences: stable extensions ⇔ stable models of normal logic programs; preferred extensions ⇔ preferred semantics of logic programs; default-logic extensions ⇔ stable extensions of the AF generated by the defaults; the stable extensions of a 2-person game’s defeat graph ⇔ winning strategies.
Inference as fixed-point computation: each semantics is the fixed point of a characteristic operator on 2^A; the order-theoretic structure (complete partial order of admissible sets) makes the theory algorithmically tractable.
Sceptical vs credulous reasoning: every AF supports both — a is sceptically accepted iff in every preferred extension; credulously accepted iff in some preferred extension. The choice is a downstream policy decision.
Why it works as a unifier: nonmonotonic reasoning, default logic, logic programming with negation-as-failure, and game-theoretic equilibria all reduce to “find a coherent set of accepted positions in the presence of mutual challenge” — which is exactly what Dung’s framework computes.

Connections

Conceptual Contribution

Claim: Acceptability of arguments under attack is the abstraction common to nonmonotonic reasoning, logic programming with negation-as-failure, default logic, and equilibrium notions in n-person games. A single, content-free framework — a directed graph of arguments and attacks plus a fixed family of acceptability conditions — captures all of them.
Mechanism: Abstract argumentation framework (A, R); characteristic function F_AF : 2^A → 2^A mapping a set to the arguments it defends; admissible / complete / grounded / preferred / stable extensions defined as fixed points of F_AF under various conditions; instantiation theorems mapping logic-programming and default-logic problems to AFs and proving extension-correspondence.
Concepts introduced/used: Argumentation Framework, Attack Relation, Admissible Set, Grounded Extension, Preferred Extension, Stable Extension, Defence (Argumentation), Sceptical Reasoning, Credulous Reasoning.
Stance: foundational technical paper.
Relates to: Conceptually the missing companion of Circumscription - A Form of Nonmonotonic Reasoning (McCarthy 1980) — both address nonmonotonicity, but Dung gives an argumentation-graph framing that plays directly with logic-programming semantics where circumscription works at the level of model-theoretic minimisation. Provides the formal substrate beneath the dialogue-game tradition: a Persuasion Dialogue (Walton & Krabbe) is operationally a process for constructing the attack edges of a shared AF and computing extensions over it. The structured-argumentation systems (ASPIC+, ABA, DeLP, defeasible logic programming) instantiate Dung’s abstract framework with rule-based languages — and the SPL/Hence defeasible-logic engine used elsewhere in this vault is in this same family. In the LLM-agent era, multi-agent debate / self-consistency protocols recapitulate Dung’s machinery: agents generate arguments, attacks are mined from contradictions, and grounded/preferred extensions correspond to convergent / multi-modal answers. The paper’s reach into n-person games supplies a bridge to the game-theoretic / mechanism-design strands of Pact - A Choreographic Language for Agentic Ecosystems and Deals Among Rational Agents.

Tags

#argumentation #nonmonotonic-reasoning #logic-programming #foundations #dung #defeasible-reasoning #multi-agent

Curry-Howard Correspondence

The deep structural identity between proofs and programs (Curry 1934, Howard 1969): propositions correspond to types, proofs to programs, and proof normalisation to program execution. The intuitionistic logic / simply-typed λ-calculus correspondence is the classical case. Linear-logic Curry–Howard (Caires & Pfenning 2010, Wadler 2012) extends the correspondence to concurrency: Linear Logic propositions ⇔ Session Types, proofs ⇔ Pi-Calculus processes, cut elimination ⇔ communication. The result is a typed concurrent calculus in which deadlock-freedom and session fidelity are corollaries of cut elimination.

In this vault

Linear Logic

Girard’s resource-aware refinement of classical/intuitionistic logic (1987): the structural rules of weakening and contraction are removed and reintroduced under exponential modalities ! / ?. Connectives split into multiplicatives (⊗, ⅋) and additives (&, ⊕). The Curry–Howard counterpart of Session Types for the Pi-Calculus (Caires–Pfenning 2010, Wadler 2012): well-typed processes are deadlock-free and session-faithful, with cut elimination ⇔ communication.

In this vault

Ambient Calculus

The process calculus of Cardelli & Gordon (1998) in which the primary mobile entity is a named bounded region (an ambient) rather than a channel name as in the Pi-Calculus. Movement is expressed by the three capabilities in n, out n, open n. Captures administrative-domain structure (firewalls, address spaces, hosts) directly in the syntax. See Mobile Ambients.

In this vault

Mobile Ambients

Reference: Cardelli, L. & Gordon, A. D. (1998). Mobile Ambients. In Foundations of Software Science and Computational Structures (FoSSaCS ’98), LNCS 1378, pp. 140–155, Springer. Journal version: Theoretical Computer Science 240(1), pp. 177–213, 2000. DOI · Open access PDF (UPenn)

Summary

Cardelli and Gordon argue that the Pi-Calculus models communication elegantly but does not natively model administrative domains — the bounded, named, hierarchically nested regions across which computation moves on the actual Internet (firewalls, address spaces, processes, machines, networks). Their ambient calculus makes the location itself the primary mobile entity. An ambient n[P] is a named bounded region containing a process P. A small set of capabilities — in n.P, out n.P, and open n.P — drive movement: in n enters a sibling ambient named n; out n exits the parent ambient if it is named n; open n dissolves the boundary of a child ambient named n, merging its contents with the current location. Communication is local: (x).P reads from a shared anonymous channel within the surrounding ambient. Mobility and access control reduce to one question — does a process possess the capability to cross a particular boundary? The calculus has standard structural-congruence-and-reduction operational semantics, a logical companion (the ambient logic, with location-modal connectives), and type systems regulating mobility. It supplies the formal substrate for reasoning about agents that physically relocate — mobile-code platforms, container migration, and (today) WASM components moving between hosts.

Key Ideas

Locations as first-class movable entities: the basic mobile thing is a named bounded region, not a name-as-channel; this captures administrative-domain structure that pure π struggles to express.
Three capabilities — in, out, open — suffice: every mobility scenario reduces to a sequence of crossings governed by capability possession; access control becomes “do you have the capability name?”
Spatial nesting as syntax: ambient terms form trees n[P | m[Q] | …]; the structural-congruence laws are spatial as well as algebraic. The ambient logic adds location modalities (@n reads “at ambient n”) for spatial reasoning.
Bounded computation: an ambient acts like a bag carrying its computation; its contents proceed concurrently inside the boundary, distinct from the outside world.
Communication restricted to local anonymous channels: a deliberate departure from π’s named channels — values are read off the local “ether” within an ambient. Gives an asymmetric model where mobility is global but communication is local.
Type systems for mobility: subsequent work (Cardelli, Ghelli, Gordon 1999/2000) gives type disciplines that statically constrain which ambients may cross which boundaries — the ancestor of capability-typed mobile-code systems.
Deliberate engineering target: motivated explicitly by Java applets, Telescript-style mobile agents, and firewall-bounded computation — process-calculus theory aimed at the engineering reality of distributed systems.

Connections

Conceptual Contribution

Claim: Modelling internet-scale distributed computation requires a process calculus in which the location is the primary mobile entity, not the channel; three boundary-crossing capabilities (in, out, open) suffice to express administrative-domain mobility, and capability possession is the natural account of access control.
Mechanism: A process language extending π-style parallel composition with ambient brackets n[P] and capability prefixes; small structural-congruence-and-reduction operational semantics; an ambient logic with spatial / location modalities; type systems controlling which ambients can perform which capabilities.
Concepts introduced/used: Mobile Ambients, Ambient Calculus, Capabilities (Ambient), Mobility, Spatial Logic, Boundary (administrative domain).
Stance: foundational technical paper.
Relates to: Sibling of the Pi-Calculus — both Milner 1992 and Cardelli & Gordon 1998 lift CCS-style fixed-topology concurrency, but along different dimensions (channel-mobility vs location-mobility). Conceptually upstream of all capability-based mobile-agent security work in the vault: Agent Tcl Flexible Secure Mobile Agents and DAgents Security Book Chapter take the engineering view, while ambients give the formal model. The capability-as-token view aligns directly with Capability Security (Dennis & Van Horn 1966, Miller’s E lineage in Robust Composition - Towards a Unified Approach to Access Control and Concurrency Control) — possession of a capability name confers, and only confers, the right to act. Modern realisations include WebAssembly modules with WASI capabilities, container ingress/egress, and sandboxed JS with capability-secured imports — a re-discovery of ambient-style boundary control under different syntactic skins.

Tags

#process-calculi #mobile-ambients #cardelli #gordon #mobility #capability-security #foundations

A Calculus of Mobile Processes

A Calculus of Mobile Processes (Parts I and II)

Reference: Milner, R., Parrow, J. & Walker, D. (1992). A Calculus of Mobile Processes, I and II. Information and Computation, 100(1), pp. 1–40 and pp. 41–77. (Reports appeared as ECS-LFCS-89-85 and -86, Edinburgh, 1989.) Companion textbook: Milner, R. (1999). Communicating and Mobile Systems: the π-Calculus. Cambridge University Press. DOI · Open access (Edinburgh)

Summary

Milner, Parrow and Walker introduce the π-calculus, a process calculus in which the names exchanged between processes are themselves the channels of communication. The earlier CCS (Milner 1980) had a fixed communication topology — process structure determined which agents could synchronise. The π-calculus drops that restriction: a single primitive, the output of one name on another (x̄⟨y⟩), simultaneously transmits a capability to communicate and reconfigures the network. The paper develops the calculus in two parts: Part I gives the syntax (input prefix, output prefix, parallel composition, restriction (νx), replication !P, summation +, match [x=y]), the structural-congruence-and-reduction operational semantics, and proves the basic algebraic theory; Part II develops a higher-order extension and the labelled-transition / bisimulation theory (early, late, and open variants of strong and weak bisimulation). The headline expressive result, established in detail in Milner’s companion Functions as Processes (1992), is that the lazy and call-by-value λ-calculi embed faithfully into the π-calculus — concurrent computation strictly subsumes sequential functional computation. The calculus has since become the standard substrate for reasoning about Mobility, Concurrency, and Session Types, and is the formal predecessor of every choreographic / multiparty-session-type result in this vault.

Key Ideas

Name-passing as the unifying primitive: a single output prefix x̄⟨y⟩.P transmits a name y over channel x; the receiver x(z).Q binds z to y and may then use it as a channel — communication and channel reconfiguration become one operation.
Restriction (νx)P: introduces a fresh, private name; combined with output, it gives scope extrusion — when a private name is communicated outside its scope, the scope expands to include the recipient. This is the formal mechanism of mobility.
Replication !P: the calculus’s only recursion construct, equivalent to P | !P; supports unbounded parallelism without an explicit fix-point.
Three bisimulation styles: early (instantiate the bound name before the transition), late (transition on a name-abstraction), open (transitions parametric in a substitution closure) — different congruence properties; open bisimulation is preserved by all contexts.
λ encodes into π: lazy and call-by-value λ-calculi translate compositionally into π, with β-reduction simulated by communication. Sequential function application is a degenerate case of concurrent name-passing.
Polyadic and monadic forms: tuples of names (x̄⟨y₁,…,yₙ⟩) can be encoded into the monadic calculus; this encoding is the basis of Sorts / type systems for π, and of session types.
Single-paper foundation for an entire research programme: Hoare’s CSP and Milner’s earlier CCS supplied process algebra over fixed topologies; π-calculus made the topology itself first-class data.

Connections

Conceptual Contribution

Claim: A single primitive — the communication of names along names — suffices to express both classical concurrency (CCS-style fixed-topology synchronisation) and the dynamic reconfiguration of communication networks; the resulting calculus subsumes the λ-calculus and serves as a universal substrate for mobile, concurrent computation.
Mechanism: Reduction-and-congruence operational semantics over a small syntax (input/output prefix, |, (νx), !, +, [x=y]); scope extrusion as the single rewrite rule that lets restricted names escape their original scope when communicated; early/late/open bisimulation as compositional behavioural equivalences; λ-encoding via continuation-passing-style translation into name communication.
Concepts introduced/used: Pi-Calculus, Name-Passing, Scope Extrusion, Mobility, Bisimulation (early, late, open), Replication, Restriction, Sorts (precursor to session types), Higher-Order Pi-Calculus.
Stance: foundational technical paper / textbook calculus.
Relates to: Direct ancestor of Session Types (Honda et al., where the name being passed carries a type describing how the recipient may use it) and through them of Multiparty Asynchronous Session Types and Structured Communication-Centred Programming for Web Services — the entire choreographic-programming line in this vault, including Pact - A Choreographic Language for Agentic Ecosystems, rests on π-calculus reductions as the underlying small-step semantics. Mobile Ambients (Cardelli & Gordon 1998) is a sibling calculus that makes locations rather than names the primary mobile entity, motivated by the difficulty of expressing administrative domains in pure π. Spi Calculus (Abadi & Gordon 1997) extends π with cryptographic primitives for protocol verification — directly relevant to the agent-security threads. Join Calculus (Fournet & Gonthier 1996) is an asynchronous, join-pattern reformulation amenable to distributed implementation. The encoding of λ into π reframes Hewitt actors as a particular discipline of π usage and supplies the formal grounding for asynchronous-message-passing concurrency in actor-based systems like Erlang. On the agent-communication side π is the missing semantic substrate for Conversation Policy and Interaction Protocols: a KQML/FIPA performative exchange is — operationally — π-calculus name-passing constrained by an ontological vocabulary, a fact made explicit by every session-typed reformulation of ACL conversations.

Tags

#process-calculi #pi-calculus #concurrency #mobility #foundations #milner #bisimulation #session-types-foundation

Bisimulation

A coinductive equivalence on labelled transition systems: two states are bisimilar iff every transition from one can be matched by a transition with the same label from the other, and the resulting states remain bisimilar. The standard behavioural equivalence for process calculi (CCS, Pi-Calculus, CSP). Strong bisimulation matches every transition including silent ones; weak bisimulation absorbs internal τ-transitions. In Pi-Calculus three sub-variants — early, late, and open — differ in when an input action’s bound name is instantiated, with open bisimulation alone preserved by all contexts.

In this vault

CCS

The Calculus of Communicating Systems (Milner 1980) — the first algebraic process calculus in which synchronisation rather than shared state is the foundation of concurrency. CCS processes are built from action prefix, sum, parallel composition, restriction, relabelling, and named recursion; communication is synchronous handshake between complementary actions. The behavioural theory is Bisimulation (a.k.a. observational equivalence). Direct predecessor of the Pi-Calculus, which lifts the fixed-topology assumption.

In this vault

A Calculus of Communicating Systems

Reference: Milner, R. (1980). A Calculus of Communicating Systems. Lecture Notes in Computer Science 92, Springer-Verlag. Companion paper: Milner, R. (1989). Communication and Concurrency. Prentice Hall. Springer (LNCS 92) · Edinburgh Research Explorer (Citation only — book.)

Summary

Milner introduces CCS, the first algebraic process calculus to make synchronisation rather than shared state the foundation of concurrency. A CCS process is built from action prefix (a.P), summation (P + Q), parallel composition (P | Q), restriction (P \ L), relabelling (P[f]), and (constant) recursion. Communication is synchronous handshake between complementary actions a and ā — paired transitions yield a silent τ. The technical heart of the monograph is the development of observational equivalence (later refined by Park into bisimulation) as a behavioural equivalence preserved by all CCS contexts: two processes are equivalent iff they can match each other’s transitions step-for-step. Earlier Milner had developed the equivalence over synchronisation trees — tree unfoldings of the LTS — and shown that CCS is sound and complete for strong equivalence given a finite axiomatisation. The calculus served as the workhorse for ten years of process-algebra research and is the direct predecessor of the Pi-Calculus, which lifted CCS’s fixed-topology assumption by making channel names mobile values. The 1989 Communication and Concurrency book is the more polished re-presentation that most readers cite.

Key Ideas

Synchronous handshake as the primitive: complementary actions on a shared name produce a silent step; concurrency is communication, not interleaving over a heap.
Algebraic, not denotational: the meaning of a CCS term is given by its position in an equational theory under bisimulation, not by translation into a domain. Laws like P + 0 = P, (P | Q) | R = P | (Q | R), and the expansion law (P | Q distributes over a sum of all possible synchronisations) form the calculational kit.
Synchronisation tree: the LTS unfolded as an action-labelled tree; equivalences over LTSs lift to equivalences over trees.
Observational equivalence ≈ bisimulation: invented and refined within the CCS programme; the standard behavioural equivalence ever since.
Restriction P \ L: hides a set of action names from the environment, forcing them to synchronise within P — this is what later inspires π’s (νx) binder, generalised to fresh names.
Recursion via constants: rather than fix-point operators, CCS uses named process equations A ≜ a.A, simpler to manipulate algebraically.
Limitations that motivate π: communication topology is fixed at a process’s birth — there is no way for a.P to communicate b to a peer who could then use b to communicate further. This restriction is exactly what name-passing in π lifts.

Connections

Conceptual Contribution

Claim: Concurrency can be developed as an algebraic theory of synchronisation in which the meaning of a process is determined by an observational equivalence preserved under all contexts; communication, not shared state, is the right primitive.
Mechanism: A small term language (prefix, sum, parallel composition, restriction, relabelling, named recursion); structural-operational-semantics rules deriving a labelled transition system; observational equivalence (≈ bisimulation) preserved by all syntactic contexts, with a complete equational axiomatisation in the finite case.
Concepts introduced/used: CCS, Synchronisation Tree, Observational Equivalence, Bisimulation, Process Calculi, Structured Operational Semantics (developed by Plotkin in dialogue with the CCS programme).
Stance: foundational technical monograph.
Relates to: Sibling of Communicating Sequential Processes (Hoare 1978), which uses an event-trace semantics and refinement orderings rather than bisimulation. Direct ancestor of the Pi-Calculus (A Calculus of Mobile Processes) which keeps the algebraic methodology but lifts the topology restriction. The actor-model line (Hewitt 1973, realised industrially in Erlang) takes asynchronous, mailbox-based messaging as primitive — historically opposed to CCS’s synchronous handshake but reconciled in asynchronous π and the Join Calculus. CCS supplies the underlying behavioural-equivalence machinery used (often implicitly) when reasoning about Conversation Policy equivalence in the ACL literature: two protocols are “the same” iff they bisimulate.

Tags

#process-calculi #ccs #milner #concurrency #foundations #bisimulation #synchronisation

Communicating Sequential Processes

Reference

Hoare, C. A. R. (1978). “Communicating Sequential Processes.” Communications of the ACM, 21(8), 666-677. URL

Summary

Hoare proposes that input, output, and concurrent composition of processes deserve the same foundational status as assignment, sequencing, and iteration. CSP is a small language in which programs are built from sequential processes that synchronise by unbuffered, typed message exchange over named channels. A send P ! v and a matching receive Q ? x rendezvous: neither proceeds until both are ready. Dijkstra’s guarded commands — with nondeterministic choice — are generalized so that a guard may include a communication action, yielding a clean treatment of external choice, alternation, and fair scheduling.

The paper walks through a progression of examples — coroutines, prime sieve, matrix multiplication, bounded buffer, recursive subroutines implemented as processes, the dining philosophers — demonstrating how seemingly exotic concurrent patterns become compact CSP programs. Hoare’s deliberate methodological stance is that structured concurrency can be as tractable as structured sequential programming, provided the primitives are well-chosen: synchronous rendezvous avoids the subtleties of mailboxes and shared state; named channels make communication explicit in the program text; guarded commands make nondeterminism principled.

CSP seeded a lineage of enormous practical and theoretical impact: occam (the transputer language), the CSP process algebra (Hoare 1985, Roscoe) with refinement-based verification via FDR, the Go programming language’s goroutines and channels, Rust’s std::sync::mpsc, and the modern “structured concurrency” revival. Together with Hewitt’s actors, CSP defines one of the two great alternatives to shared-memory threads.

Key Ideas

Synchronous message passing: unbuffered rendezvous between named processes; no shared memory.
Named channels / named processes: communication is part of program structure, syntactically explicit.
Guarded commands with I/O guards: nondeterministic alternation and repetition over communications.
Parallel composition (||): processes execute concurrently, synchronizing only at matched send/receive.
No implicit buffering: forces designers to reason about liveness and deadlock directly.
Refinement and equivalence: later formalized as a process algebra with bisimulation / failures refinement.
Structured concurrency: parallelism as a first-class program-structuring mechanism, not threads-as-afterthought.

Connections

Actor Model — the other great message-passing tradition; CSP is channel-centric where actors are mailbox-centric.
A Universal Modular Actor Formalism for Artificial Intelligence
Hoare Logic — Hoare’s earlier work on axiomatic reasoning underlies his insistence on structured primitives.
Time Clocks and the Ordering of Events in a Distributed System — rendezvous provides a stronger local synchrony than Lamport’s messages.
Let It Crash

Conceptual Contribution

A Universal Modular Actor Formalism for Artificial Intelligence

Reference

Hewitt, C., Bishop, P., & Steiger, R. (1973). “A Universal Modular Actor Formalism for Artificial Intelligence.” Proceedings of the 3rd International Joint Conference on Artificial Intelligence (IJCAI), 235-245. URL

Summary

Hewitt, Bishop, and Steiger introduce the Actor — a universal computational primitive that unifies data, procedure, and process under a single kind of object. An actor is an active agent with behavior defined entirely by the messages it sends and receives. All computational structures — numbers, functions, semaphores, cells, queues, interpreters — are modeled uniformly as actors that respond to messages. Control flow and data flow are inseparable; sending a message replaces goto, call-return, interrupt, and semaphore operations with a single mechanism.

The paper grew out of the PLANNER project and explicit dissatisfaction with the von Neumann / stored-program paradigm dominant in AI languages. In place of “program counter + global memory + interrupts,” the actor model offers local state per actor, inherent concurrency via simultaneous message sends, and a coherent account of parallelism that scales from fine-grained numeric computation to large, autonomous agents. The authors emphasize intentions as first-class properties — an actor’s intention is the contract it guarantees to satisfy for its senders, supporting a form of declarative meta-evaluation and debugging.

Hewitt’s framework anticipated and influenced a long arc of subsequent work: Smalltalk’s message-passing object model, Agha’s formalization of actor semantics, Erlang/OTP’s supervised processes and let-it-crash philosophy, the Akka framework, CSP (Hoare) which formalized a closely related but channel-centric style, and contemporary actor-based agentic systems. The paper’s insistence that “creation, control, and communication” are one mechanism remains the defining alternative to shared-memory concurrency.

Key Ideas

Actor = message-receiving agent: a single primitive subsumes data, procedures, processes.
Message passing only: no shared memory, no goto, no interrupt, no semaphore.
Inseparability of control and data: computation is intrinsic — “ask not what you can do to an object; ask what the actor will do for you.”
Inherent concurrency: every message send is potentially parallel.
Intentions / contracts: each actor publishes obligations; meta-evaluators check that behavior satisfies intentions.
Modularity via encapsulation: actors expose only message interfaces; internal state is private.
Universality: the formalism expresses every computational construct needed for AI programming without primitive aggregates.
Hierarchies of scheduling, intention, monitoring, binding, resource management: supervisory structures emerge naturally.

Connections

Actor Model
Programming Erlang Second Edition — the most successful large-scale realization.
Let It Crash
Supervision Tree
A Language-Based Approach To Prevent DDoS
The Society of Mind — Minsky’s agent-of-agents shares the intuition.
Communicating Sequential Processes — Hoare’s contemporary rival formulation.
Hoare Logic

Conceptual Contribution

End-to-End Arguments in System Design

Reference

Saltzer, J. H., Reed, D. P., & Clark, D. D. (1984). “End-to-End Arguments in System Design.” ACM Transactions on Computer Systems, 2(4), 277-288. URL

Summary

Saltzer, Reed, and Clark articulate a design principle for layered distributed systems that had long been used but rarely stated explicitly: functions requiring knowledge and action at the endpoints of a communication — such as reliable delivery, integrity checking, encryption, duplicate suppression — cannot be fully and correctly implemented at lower layers. Lower-layer implementations are at best performance optimizations; the end-to-end argument says they cannot substitute for the end-level check.

The canonical example is careful file transfer between two hosts. Even if the communication network offers reliable delivery, threats remain — disk errors at either host, memory corruption during buffering, software bugs in the file-transfer program itself. No amount of reliability layered into the network can defend against these; only an end-to-end checksum computed from the file on disk at host A and verified against the file on disk at host B closes the loop. The paper then iterates the argument through encryption (only the endpoints know the plaintext), duplicate suppression (only the application knows what “duplicate” means at the transaction level), delivery acknowledgements, and crash recovery.

The principle is a design heuristic, not an absolute rule: performance sometimes justifies redundant lower-layer mechanisms (e.g., per-hop error correction in a very noisy link). But it inverts the naïve “make the network as reliable as possible” instinct, provides the intellectual backbone for the Internet’s dumb-network / smart-edges architecture, and underwrites TCP’s placement in the hosts rather than the routers. Its influence extends to REST’s principled avoidance of server-side session state, to security architectures that refuse to trust intermediaries, and to the “fate-sharing” style of protocol design.

Key Ideas

End-to-end argument: a function that must be correct at endpoints cannot be completely implemented below the endpoints.
Lower layers as optimization: partial lower-level help is only a performance enhancement, never a correctness substitute.
Careful file transfer: the worked example — only an end-to-end checksum protects against all failure modes.
Dumb core, smart edges: Internet architecture as the principle’s canonical application.
Encryption placement: true confidentiality requires endpoint encryption; network-level encryption is not enough.
Acknowledgements: application-meaningful acks (e.g., “request served”) require endpoint involvement.
Cost-benefit nuance: redundancy below is justified when error rate or cost of retry makes it worthwhile.

Connections

Principled Design Of The Modern Web Architecture — Fielding’s REST thesis formalizes many end-to-end commitments.
REST
LangSec — input parsing at the application boundary is itself an end-to-end verification.
Actor Model — supervisor-style recovery relies on end-to-end state ownership.
Impossibility of Distributed Consensus with One Faulty Process — endpoints cannot delegate liveness to lower layers either.

Conceptual Contribution

Knowledge and Common Knowledge in a Distributed Environment

Reference

Halpern, J. Y., & Moses, Y. (1990). “Knowledge and Common Knowledge in a Distributed Environment.” Journal of the ACM, 37(3), 549-587. URL

Summary

Halpern and Moses recast distributed protocol design as knowledge transformation: sending a message changes the knowledge state of the system, and correctness specifications can be stated in terms of what individual processes, groups, or “the system” know at various points. The paper develops a formal epistemic logic for distributed systems with operators K_i (agent i knows), E (everyone knows), and C (common knowledge — everyone knows that everyone knows, to infinite depth).

The central technical result is striking: in a truly asynchronous distributed system, common knowledge is unattainable. The classical “coordinated attack” problem (two generals must attack simultaneously but communicate only via lossy messengers) is unsolvable because simultaneous action requires common knowledge of the time to attack, and no finite message chain ever reaches the fixpoint. The muddy children puzzle — a beloved epistemic set piece walked through in the opening — shows how a public announcement can create common knowledge that sequential private reasoning cannot, illuminating why synchronous broadcast matters.

Because strict common knowledge is unattainable, the paper introduces and characterises weaker variants: eventual common knowledge, ε-common knowledge (bounded delay), timestamped common knowledge, and concurrent common knowledge. Each corresponds to a different system model (synchronous, partially synchronous, etc.) and a different class of solvable coordination tasks. This framework turned “what does a protocol achieve?” into a precise epistemic question and seeded the entire field of Theoretical Aspects of Reasoning about Knowledge (TARK).

Key Ideas

Epistemic hierarchy: distributed knowledge ⊑ someone knows ⊑ everyone knows (E) ⊑ common knowledge (C).
Common knowledge (C): fixpoint E^ω — needed for any simultaneous coordinated action.
Coordinated attack / muddy children: canonical illustrations of how public announcements create C.
Impossibility: in async or even synchronous-with-uncertain-delivery systems, C cannot be attained by message exchange.
Weakenings: ε-C (bounded-time C), eventual C, timestamped C, concurrent C — each aligned with a synchrony assumption.
Protocols as knowledge transformers: specifications are claims about K_i, E, C; message sends are knowledge updates.
Runs-and-systems semantics: each global history is a “run”; agent’s knowledge is the set of runs it cannot distinguish from the actual one.

Connections

Epistemic Logic
Epistemic S5
Knowing What vs Knowing That
The Synthesis of Digital Machines with Provable Epistemic Properties — Rosenschein-Kaelbling operationalise this framework.
Time Clocks and the Ordering of Events in a Distributed System — the “local history” underpinning indistinguishable runs is Lamport’s past-cone.
Impossibility of Distributed Consensus with One Faulty Process — consensus impossibility has an epistemic reading: common knowledge of a decision cannot be attained.
CAP Theorem

Conceptual Contribution

Brewers Conjecture and the Feasibility of Consistent Available Partition-Tolerant Web Services

Brewer’s Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services

Reference

Gilbert, S., & Lynch, N. (2002, revisited 2012). “Perspectives on the CAP Theorem.” MIT / National University of Singapore. URL

Summary

This paper is the formal proof and later retrospective of Brewer’s CAP conjecture: in a distributed system subject to communication failures, no web service can simultaneously guarantee Consistency (atomic read/write), Availability (every request receives a response), and Partition-tolerance (the system continues to operate when messages are lost between nodes). The proof is elegantly short: partition the servers into two groups; a write on one side and a read on the other must answer, but the read cannot know of the write, so either consistency or availability must fail.

The authors situate CAP within the deeper trade-off between safety and liveness properties in unreliable systems — the very trade-off FLP formalized for consensus. Consistency is a safety property (“nothing bad happens”), availability is a liveness property (“something good eventually happens”), and the unreliability axis includes partitions, crashes, and Byzantine faults. CAP is then one specific instance of the general fact that safety + liveness are jointly unattainable in sufficiently unreliable systems.

The paper distinguishes practical regimes (always-consistent with best-effort availability; always-available with weak/eventual consistency; hybrid tactics) and connects to partial synchrony results (Dwork, Lynch, Stockmeyer) that quantify exactly how much timing reliability is needed. CAP has become a rallying slogan and a misused one — the paper explicitly warns it is a theorem about adversarial partitions, not a license to abandon consistency whenever convenient.

Key Ideas

CAP theorem: pick at most two of consistency, availability, partition-tolerance in an unreliable network.
Asynchronous impossibility: even without actual partitions, async delays force the same trade-off — you cannot distinguish a slow network from a partitioned one.
Safety vs. liveness lens: CAP is a concrete instance of a broader unreliability theorem.
Weak consistency models: eventual, causal, sequential — engineered escapes from strict CAP.
Synchrony continuum: fully synchronous → partially synchronous → fully asynchronous; feasibility varies along it.
Practical taxonomy: CP, AP, and CA-only-without-partitions system designs.
Not a license: the theorem is often cited to justify weaker-than-needed guarantees; read carefully.

Connections

CAP Theorem
CALM Theorem — identifies the programs for which consistency does not require coordination.
Keeping CALM - When Distributed Consistency is Easy
Coordination Avoidance
Gossip Protocols — eventual consistency in the AP regime.
Impossibility of Distributed Consensus with One Faulty Process — FLP is CAP’s consensus cousin.
Time Clocks and the Ordering of Events in a Distributed System

Conceptual Contribution

Impossibility of Distributed Consensus with One Faulty Process

Reference

Fischer, M. J., Lynch, N. A., & Paterson, M. S. (1985). “Impossibility of Distributed Consensus with One Faulty Process.” Journal of the ACM, 32(2), 374-382. URL

Summary

The FLP result is the canonical impossibility theorem of asynchronous distributed computing. Its statement is sharp: no deterministic consensus protocol can guarantee termination in an asynchronous message-passing system if even a single process may crash. Unlike earlier results that required Byzantine faults or lossy networks, FLP assumes reliable messaging and only one benign crash failure — yet still derives impossibility.

The proof proceeds by showing that every consensus protocol admits an initial bivalent configuration (one from which either decision value is still reachable), and that from any bivalent configuration an adversary scheduler can always delay one message to force the system into another bivalent configuration. Thus an admissible run exists in which no process ever decides. The core technical tool is the commutativity of disjoint process steps (Lemma 1) and a careful analysis of “critical” configurations where a specific process’s next step is decision-forcing.

The result cleaves distributed computing into what is possible under various synchrony assumptions. Real-world protocols respond by weakening one axis: Paxos and Raft adopt partial synchrony and accept that liveness can only be guaranteed “eventually”; randomized consensus (Ben-Or, Rabin) achieves termination with probability 1; failure detectors (Chandra-Toueg ◊S) encapsulate the synchrony needed. FLP remains the bedrock boundary against which all consensus engineering is measured.

Key Ideas

Consensus problem: N processes, binary inputs; non-faulty processes must all decide the same value; some initial configuration must admit each decision.
Asynchronous model: unbounded message delays; no clocks; no timeouts.
One crash failure: the weakest possible fault assumption that still breaks consensus.
Bivalent configurations: states from which both 0 and 1 outcomes are still reachable.
Adversary scheduler: by reordering message deliveries, keeps the system in a bivalent configuration forever.
Safety vs. liveness: FLP shows safety + liveness + fault-tolerance cannot coexist in pure async.
Escape hatches: partial synchrony, randomization, failure detectors, or accepting non-termination in corner cases.

Connections

CAP Theorem — CAP is a direct relative: in partition-prone systems, atomic read/write also unattainable.
CALM Theorem — monotonic logic sidesteps consensus by avoiding it.
Keeping CALM - When Distributed Consistency is Easy
Coordination Avoidance — the design pattern motivated by FLP.
Gossip Protocols — probabilistic convergence as an alternative to deterministic agreement.
Time Clocks and the Ordering of Events in a Distributed System — Lamport’s logical time underlies the proof’s commutation arguments.
Knowledge and Common Knowledge in a Distributed Environment — common knowledge likewise unattainable in async systems.

Conceptual Contribution

Time Clocks and the Ordering of Events in a Distributed System

Time, Clocks, and the Ordering of Events in a Distributed System

Reference

Lamport, L. (1978). “Time, Clocks, and the Ordering of Events in a Distributed System.” Communications of the ACM, 21(7), 558-565. URL

Summary

Lamport’s seminal paper reframes time in distributed systems. Rather than depending on physical clocks that cannot be perfectly synchronized, he defines a partial order on events — the “happened-before” relation (→) — using only causality derived from local process order and message exchange. Two events are concurrent iff neither happened before the other. This reorientation showed that a distributed system’s truth about “when” is inherently relational, not absolute, mirroring the space-time view of special relativity.

Lamport then introduces logical clocks — counters per process that assign numbers to events such that a → b implies C(a) < C(b). A simple algorithm (increment on local events; piggyback timestamps on messages; bump local clock on receipt) provides this. Extending the partial order to a total order via tiebreaking by process ID enables the classic distributed mutual exclusion algorithm that uses only message passing without a central coordinator.

The final portion generalises to physical clocks, deriving synchronization bounds that tolerate clock drift and message delay. The paper is foundational: it underlies vector clocks, causal broadcast, state-machine replication, Paxos, version vectors in Dynamo/Riak, CRDT causality tracking, and distributed snapshotting.

Key Ideas

Happened-before (→): irreflexive partial order capturing causal precedence.
Concurrency: a ∦ b when neither a → b nor b → a; cannot be eliminated in a distributed system.
Logical clocks: monotone counters satisfying the Clock Condition; do not measure real time but respect causality.
Total ordering: arbitrary tie-break on process IDs yields a global total order usable for coordination.
Distributed mutual exclusion: a worked example of using total ordering of timestamped requests to implement a resource without a central arbiter.
Space-time diagrams: process lines + message arrows — a durable visual vocabulary for distributed reasoning.
Physical clock synchronization: bounded drift + bounded message delay yield clock-sync with provable error.

Connections

CAP Theorem — partitions and concurrent writes are grounded in Lamport’s concurrent events.
CALM Theorem — monotonic computation avoids the coordination that Lamport’s algorithms provide.
Keeping CALM - When Distributed Consistency is Easy
Coordination Avoidance — when → does not need to be totally ordered.
Gossip Protocols — epidemic dissemination implicitly maintains a causal partial order.
Impossibility of Distributed Consensus with One Faulty Process — FLP shows limits of coordination Lamport makes feasible in fault-free settings.
Knowledge and Common Knowledge in a Distributed Environment — epistemic reading of causal pasts.

Conceptual Contribution

Toward Principles for the Design of Ontologies Used for Knowledge Sharing

Reference: Gruber, T. R. (1995). International Journal of Human-Computer Studies, 43(5–6), 907–928. Substantial revision of a 1993 paper presented at the International Workshop on Formal Ontology (Padova). Also Stanford KSL Technical Report 93-04. Source file: gruber_onto_design.pdf. URL

Summary

Gruber articulates the engineering foundations of ontology design for knowledge sharing. An ontology is defined as an explicit specification of a conceptualization: a vocabulary of classes, relations, functions, and object constants, together with axioms constraining their interpretation, intended to allow heterogeneous agents to communicate about a domain without sharing a global knowledge base. Agents commit to an ontology when their observable behaviour is consistent with its definitions — a notion of commitment grounded in Newell’s Knowledge Level and Levesque’s tell-and-ask interface. Common ontologies thus underwrite interoperability at the knowledge level rather than at the symbol or data level.

Gruber proposes five design criteria: (1) Clarity — definitions should be objective and, where possible, complete (necessary and sufficient conditions); (2) Coherence — sanctioned inferences must be consistent with informal definitions; (3) Extendibility — anticipate new uses so the vocabulary can be monotonically extended without revision; (4) Minimal encoding bias — conceptualise at the knowledge level, independent of symbol-level representation; (5) Minimal ontological commitment — say only what is required for the intended knowledge-sharing tasks, leaving maximum freedom for specialisation. He discusses the tradeoffs — especially between extendibility and minimal commitment — and illustrates the criteria through case studies in engineering mathematics (physical quantities, units, algebras) and bibliographic data, contrasting alternative design choices against the criteria. The paper is the engineering charter for the ontology-sharing tradition that produced Ontolingua, KIF, and the modern Semantic Web.

Key Ideas

Ontology = explicit specification of a conceptualization.
Ontological commitment: observable behaviour consistent with definitions.
Knowledge-level (not symbol-level) specification (Newell).
Tell-and-ask interface as the model of agent knowledge use (Levesque).
Five design criteria: clarity, coherence, extendibility, minimal encoding bias, minimal commitment.
Design tradeoffs, particularly extendibility vs. minimal commitment.
Case studies: engineering mathematics and bibliographic data.
Ontology as shared vocabulary, not shared belief.

Connections

Conceptual Contribution

Claim: Ontologies are designed artifacts for knowledge sharing and should be evaluated by objective engineering criteria — clarity, coherence, extendibility, minimal encoding bias, and minimal ontological commitment — rather than by a priori notions of naturalness or metaphysical truth.
Mechanism: Gruber grounds the account in the Knowledge Level: an ontology specifies a conceptualization via a logical vocabulary with definitional and constraint axioms; an agent commits to the ontology when its tell/ask behaviour respects those definitions. He derives the five criteria from the requirements of knowledge-sharing interoperability, works through their inherent tensions (e.g., clarity favours complete definitions while minimal commitment favours weaker theories; extendibility favours larger vocabulary while minimal commitment favours smaller), and illustrates the application of the criteria in case studies that compare alternative representational choices.
Concepts introduced/used: Ontology, Ontological Commitment, Conceptualization, Knowledge Level, Clarity, Coherence, Extendibility, Encoding Bias, Minimal Ontological Commitment
Stance: engineering methodology
Relates to: Canonical definition inherited by Ontologies, Ontology Engineering and Handbook On Ontologies; underpins the shared-vocabulary assumption of KQML and A Common Ontology Of ACLs; supplies the design rationale behind Ontolingua Portable Ontology Specifications.

Tags

The Bitter Lesson

Reference: Sutton, R. S. (March 13, 2019). Essay on personal website, Incomplete Ideas. Not a PDF — HTML essay, captured via ar-crawl. URL

Summary

Sutton’s short but enormously influential essay argues that seventy years of AI research teach one lesson: general methods that leverage computation are ultimately most effective, by a large margin, and attempts to encode human domain knowledge tend to plateau and eventually obstruct progress. The ultimate driver is Moore’s law — the exponentially falling cost of computation — which guarantees that whatever computational budget a method can exploit will become dramatically larger on timescales shorter than a research career. Researchers, pressed for short-term gains, routinely build in human understanding; this helps locally but impedes the methods that scale.

He marshals four case studies to make the point concrete: computer chess (Deep Blue’s brute-force search beat knowledge-engineered systems in 1997, to their practitioners’ dismay); computer Go (a 20-year delay of the same pattern, culminating in search + self-play value learning); speech recognition (statistical HMMs and later deep learning displaced phoneme/vocal-tract-engineered systems); and computer vision (edges, SIFT, generalized cylinders replaced by convolutional nets). The two methods that scale arbitrarily with compute are search and learning. The deeper second lesson: the contents of minds are irredeemably complex, so we should not try to build simple theories of space, objects, multi-agent interaction, or symmetry into systems; we should instead build meta-methods that can discover that complexity themselves. “We want AI agents that can discover like we can, not which contain what we have discovered.”

Key quotes preserved for future reference:

“The biggest lesson that can be read from 70 years of AI research is that general methods that leverage computation are ultimately the most effective, and by a large margin.”

“The two methods that seem to scale arbitrarily in this way are search and learning.”

“We have to learn the bitter lesson that building in how we think we think does not work in the long run.”

Attention Is All You Need

Reference: Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, L., & Polosukhin, I. (2017). Advances in Neural Information Processing Systems 30 (NeurIPS). arXiv:1706.03762. Source file: vaswani_attention_is_all_you_need.pdf. URL

Summary

The paper introduces the Transformer, a sequence-transduction architecture that dispenses entirely with recurrence and convolution and relies solely on attention mechanisms to model dependencies between input and output tokens. An encoder stack of N=6 identical layers, each composed of a multi-head self-attention sub-layer and a position-wise feed-forward sub-layer (with residual connections and layer normalisation), encodes the source; a symmetric decoder stack augments each layer with masked self-attention and cross-attention to the encoder output. Because the architecture has no inherent notion of token order, sinusoidal positional encodings are added to the input embeddings.

The core primitive is scaled dot-product attention, Attention(Q,K,V) = softmax(QKᵀ/√dₖ)V, extended to multi-head attention by linearly projecting Q, K, V h=8 times into lower-dimensional subspaces, running attention in parallel, and concatenating the results. The motivation is computational: self-attention has O(1) sequential operations and O(1) maximum path length between any two positions — much shorter than recurrent or convolutional alternatives — enabling far greater parallelism and better gradient flow over long distances. The Transformer achieves state-of-the-art BLEU on WMT 2014 En–De (28.4) and En–Fr (41.8) at a small fraction of prior training cost and generalises to constituency parsing. It is the architectural substrate on which virtually all subsequent large language models are built.

Key Ideas

Pure attention architecture; no recurrence or convolution.
Scaled dot-product attention with 1/√dₖ scaling to stabilise softmax gradients.
Multi-head attention for attending to different representation subspaces.
Three uses of attention: encoder self-attention, decoder masked self-attention, encoder-decoder cross-attention.
Sinusoidal positional encodings enable extrapolation beyond training lengths.
O(1) path length supports learning of long-range dependencies.
Massive parallelism compared to RNNs; dramatic training cost reduction.

Connections

Conceptual Contribution

Claim: Recurrence and convolution are unnecessary for high-quality sequence transduction; an architecture built entirely from (multi-head, self-)attention and feed-forward layers outperforms prior state-of-the-art on machine translation while training in a fraction of the time.
Mechanism: Replace RNN hidden-state chains with an encoder-decoder stack of identical layers, each using scaled dot-product multi-head attention plus position-wise FFN with residual connections and layer norm; inject order via sinusoidal positional encodings; use masked self-attention in the decoder to preserve autoregression; exploit O(1) sequential complexity and O(1) max path length to parallelise across sequence positions and shorten gradient paths to long-range dependencies.
Concepts introduced/used: Transformer, Self-Attention, Multi-Head Attention, Positional Encoding, Scaled Dot-Product Attention, Encoder-Decoder Attention
Stance: empirical architecture paper
Relates to: Architectural substrate for Language Models are Few-Shot Learners, Toolformer and the entire LLM Agents literature; exemplifies the scaling-over-structure thesis of The Bitter Lesson; reshapes what “agent architecture” means relative to Intelligent Agents Theory and Practice’s 1990s taxonomy.

Tags

Logic and Conversation

Reference: Grice, H. P. (1975). In P. Cole & J. L. Morgan (Eds.), Syntax and Semantics, Vol. 3: Speech Acts, pp. 41–58. Academic Press. (Originally delivered as the 1967 William James Lectures at Harvard.) Source file: grice_logic_and_conversation.pdf. URL

Summary

Grice’s foundational paper introduces the theory of conversational implicature: the mechanism by which speakers convey more than they literally say. Starting from the divergences formalists find between natural-language connectives (and, or, if, not, all, some) and their formal analogues, Grice argues the divergences do not show natural language is defective; rather, they arise from principles governing rational cooperative exchange, not from logical form.

At the centre is the Cooperative Principle: “Make your conversational contribution such as is required, at the stage at which it occurs, by the accepted purpose or direction of the talk exchange in which you are engaged.” The principle decomposes into four categories of maxims — Quantity (be as informative as required, no more), Quality (try to make your contribution true), Relation (be relevant), and Manner (be perspicuous). Speakers exploit these maxims — by apparently flouting them while the Cooperative Principle remains in force — to generate conversational implicatures that the hearer can calculate. The paper distinguishes what is said from what is implicated, and conventional from conversational implicatures, establishing the framework in which pragmatics has operated ever since. Its picture of communication as rational, cooperative, defeasible inference over an idealised shared purpose became a touchstone for ACL design, HCI dialogue systems, and the pragmatics of LLM prompting.

Key Ideas

What is said vs. what is implicated.
Conventional vs. conversational implicature.
Cooperative Principle as constitutive of rational discourse.
Four maxim categories: Quantity, Quality, Relation, Manner.
Implicatures arise from (apparent) maxim-flouting under the CP.
Implicatures are calculable, cancellable, non-detachable.
Natural-language/formal-logic divergences need not reflect semantic defect.

Connections

Conceptual Contribution

Claim: Successful communication rests on a presumed Cooperative Principle and its four categories of maxims; apparent violations of the maxims, against the background of presumed cooperation, generate implicatures — inferences about speaker meaning that go beyond literal content.
Mechanism: Grice frames discourse as goal-directed rational cooperation; derives the Cooperative Principle as a rationality constraint on contributions; distinguishes its maxims by Kantian category; shows that a speaker who says p while flouting a maxim (e.g., irrelevantly, uninformatively, or obscurely) signals that a further proposition q must be inferred to restore the presumption of cooperation — q is then conversationally implicated. Implicatures are calculable from the maxims plus context, cancellable without contradiction, and non-detachable from what is said.
Concepts introduced/used: Cooperative Principle, Conversational Implicature, Conventional Implicature, Gricean Maxims, Speaker Meaning, What Is Said
Stance: philosophical/pragmatic theory
Relates to: Complements the illocutionary classification of A Taxonomy of Illocutionary Acts by supplying a theory of pragmatic enrichment; informs the semantic/pragmatic layer distinctions in Agent Communication Languages and critiques of mentalistic ACL semantics in Agent Communication Languages - Rethinking the Principles; underpins the rational-speaker assumptions implicit in prompt engineering and LLM Agents.

Tags

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

True Believers - The Intentional Strategy and Why It Works

True Believers: The Intentional Strategy and Why It Works

Reference: Dennett, D. C. (1981). In A. F. Heath (Ed.), Scientific Explanations, Oxford University Press. Reprinted in The Intentional Stance (1987, MIT Press, ch. 2) and in Mind Design II (1997). Source file: dennett_true_believers.pdf. URL

Summary

Dennett’s canonical defence of the intentional stance: a predictive strategy in which one treats a system as a rational agent with beliefs and desires, works out what a rational agent so situated ought to do, and predicts it will do that. The stance is contrasted with the physical stance (predict from physical laws and microstructure) and the design stance (predict from presumed function). Belief is a perfectly objective phenomenon, but one discernible only from the point of view of an adopter of this strategy; a system is a true believer just in case its behaviour is reliably predictable by intentional ascription.

Dennett argues this vindicates a “mild realism” (or “interpretationism”) about belief against both hard-core realism (beliefs as sentence-like tokens in the head) and eliminativism. The remarkable empirical fact is that the intentional strategy works — on people, animals, chess programs, even thermostats (in a degenerate way) — because evolution and engineering produce systems whose behaviour tracks their interests given accurate beliefs. This pattern of success is what there is to being a believer; no further fact about inner sentential structure is required. The paper grounds the philosophical licence to ascribe mental states to artificial agents and thus underwrites the mentalistic vocabulary of agent theory.

Key Ideas

Three stances: physical, design, intentional.
Intentional strategy: assume rationality, compute ought-to-do, predict.
True believer = system reliably predicted by the intentional strategy.
Belief is objective but stance-relative (mild realism / interpretationism).
Natural selection explains why the strategy works on organisms.
Thermostats as degenerate (but continuous) intentional systems.
Licence for mentalistic ascription to artificial agents.

Connections

Conceptual Contribution

Claim: Beliefs and desires are objective but stance-relative — a system genuinely has them just in case adopting the intentional strategy (assume rationality with appropriate beliefs/desires and predict accordingly) reliably predicts its behaviour.
Mechanism: Dennett distinguishes physical, design, and intentional stances; defines the intentional strategy operationally (attribute beliefs the system ought to have given its perceptual and epistemic history, attribute desires it ought to have given its biological/functional role, predict the rational action); argues success of the strategy on people, animals, and artefacts is an empirical fact explained by evolutionary/design pressures, and that this success is all there is to being a believer — no further requirement of language-of-thought tokens.
Concepts introduced/used: Intentional Stance, True Believer, Mild Realism, Design Stance, Physical Stance, Rationality Assumption
Stance: philosophical theory
Relates to: Justifies the ascription of BDI mental states to artificial systems in Modeling Rational Agents within a BDI-Architecture, Intelligent Agents Theory and Practice and Agent-Oriented Programming; cohabits with Two Faces of Intention as a pillar of agent-theoretic philosophy; foreshadows functional-role arguments in Society of Mind.

Tags

We-Intention

Tuomela & Miller’s (1988) concept: an intention to do something as part of a group — operationally I intend that we φ rather than I intend that I do my part of φ. Tuomela argued that we-intentions are irreducible to the individual intentions of the group’s members; the alternative reductive position is held by Bratman (1992, Shared Cooperative Activity) and Cohen & Levesque (1991), who show that a sufficiently rich structure of recursively-nested individual intentions can capture joint action without invoking a primitive group subject. The dispute is partly empirical, partly definitional, and partly programmatic — the reductive position better fits computational MAS implementations; the irreducibility position better fits descriptive social ontology.

In this vault

We-intentions

Reference: Tuomela, R. & Miller, K. (1988). We-intentions. Philosophical Studies, 53(3), pp. 367–389. (Extended in Tuomela, R. (2007). The Philosophy of Sociality: The Shared Point of View. Oxford University Press.) DOI/Springer · Open access PDF (Academia.edu)

Summary

Tuomela and Miller introduce the analysis of we-intentions — intentions of the form “we will do X” — that became the central rival to Bratman’s reductive analysis of joint action. Their headline thesis: a we-intention is not reducible to any combination of individual I-intentions of the form “I will do my part.” A genuine we-intention has the structure: I intend that we (you and I) do X together; we mutually believe that we have this intention; this mutual belief is in part the reason we have the intention. The key features that resist reduction are (i) the content of the intention names the group as the agent — “we will” — and (ii) the intention is partly constituted by the mutual belief that the participants share it, in a way that no individual-intention combination can match. Tuomela’s later work elaborates this into a comprehensive social ontology distinguishing I-mode action (acting as a private individual, even when in a group) from we-mode action (acting as a member of a group with group-level reasons). The we-intention analysis is the main philosophical alternative to the Bratman reductive position; in MAS the dispute manifests as the choice between (a) implementing joint action via richly nested individual intentions (Cohen & Levesque joint-intention models, SharedPlans) and (b) treating the group as a primitive locus of intention (DAI multi-agent organisations, electronic-institution frameworks). The dispute has practical consequences for which kinds of failure modes a multi-agent system is susceptible to: reductive systems can fail through individual rationality undermining group action, while we-mode systems can fail through group-level reasoning detached from individual responsibility.

Key Ideas

We-intention structure: I intend that we do X together; we mutually believe that we have this intention; the mutual belief is part of the reason we have the intention. The reflexive grounding in mutual belief is the key feature.
Irreducibility thesis: no combination of individual I-intentions of the form “I will do my part of X” captures the content of “we will do X.” The we-intention’s content names the group as the agent.
I-mode vs we-mode (Tuomela 2007): even within a group, an agent may act in I-mode (treating others as instrumental) or we-mode (treating the group’s reasons as genuinely group-level). The distinction is normative as well as descriptive.
Mutual belief as constitutive: we-intentions are partly constituted by the mutual belief that they are shared — change the mutual belief and the we-intention itself changes, in a way that has no analogue in individual intentions.
Group as agent: the analysis takes seriously the locution of group agency. We won the game; we signed the treaty. The locutions are not (Tuomela argues) elliptical for individual contributions; they ascribe action to the group as such.
Connection to social facts: we-intentions are the building blocks of social institutions — money, marriage, governments — which exist only because their participants mutually intend that they exist (cf. Searle 1995, The Construction of Social Reality).

Connections

Conceptual Contribution

Claim: A we-intention — an intention of the form “we will do X” — is irreducible to any combination of individual intentions of the form “I will do my part.” The content names the group as the agent, and the intention is partly constituted by the mutual belief that the participants share it. Joint action is genuinely group-level; the reduction programme (Bratman, Cohen-Levesque, Grosz-Kraus) misses what is distinctive about it.
Mechanism: Conceptual analysis of the locution “we intend”; specification of the reflexive structure (mutual belief as part of the reason); arguments against various reductive proposals; later development (Tuomela 2007) into the I-mode / we-mode distinction.
Concepts introduced/used: We-Intention, We-mode vs I-mode, Group Agency, Mutual Belief as constitutive, Social Institutional Facts.
Stance: foundational philosophical paper; the canonical alternative to Bratman’s reductive programme.
Relates to: Direct philosophical opposition to Bratman 1992 (and the computational descendants Cohen & Levesque 1991, Grosz & Kraus 1996) — Bratman holds that joint action reduces to recursively nested individual intentions, Tuomela holds that a primitive group intention is needed. The dispute is partly definitional but has practical consequences: implementations adopting the reductive position end up with rich individual-intention machinery (MAS frameworks following BDI / Cohen-Levesque), while implementations adopting we-mode primitives tend toward organisation-level constructs (electronic institutions, Agent Communication And Institutional Reality). Norms and Obligations and the institutional-fact tradition (Searle 1995) are conceptual cousins. In LLM-agent settings the dispute manifests as the choice between (a) individual LLM agents with theory-of-mind reasoning about each other’s intentions and (b) higher-level group-policy reasoning that treats the multi-agent system as a single decision-making locus — both approaches appear in the literature, often without explicit acknowledgement of the underlying philosophical commitment.

Tags

#joint-action #we-intentions #tuomela #philosophy-of-action #foundations #social-ontology

Mutual Belief

The doxastic counterpart of common knowledge: A believes p, A believes B believes p, A believes B believes A believes p, … — without requiring that p be true. The operative epistemic condition in SharedPlans (Grosz & Kraus 1996), Cohen & Levesque’s joint-intention models, and most BDI-style multi-agent reasoning. Easier to attain in distributed asynchronous systems than common knowledge (Halpern & Moses 1990 — common knowledge is often unattainable; mutual belief is a practical relaxation).

In this vault

SharedPlans

Grosz & Kraus’s (1996) computational framework for collaborative joint action: a SharedPlan is a group-level structure carrying mutual beliefs about who is doing what, why, and how, with two intention modalities (Int.To for own actions, Int.Th for actions of others or the group). Most real collaboration involves partial SharedPlans, refined incrementally through meta-intentions to complete the plan, help others, and communicate. The canonical computational realisation of Bratman’s Shared Cooperative Activity.

In this vault

Meshing Subplans

Bratman’s (1992) construction in Shared Cooperative Activity: in genuine cooperative joint action, each participant forms a subplan for their own contribution, and the subplans must mesh — be positively coordinated rather than merely consistent. Stronger than non-interference: the subplans must positively support each other and not inadvertently undermine each other’s success conditions. Computational realisation in SharedPlans (Grosz & Kraus 1996).

In this vault

Shared Cooperative Activity

Bratman’s (1992) philosophical analysis of joint cooperative action: SCA requires (1) mutual responsiveness to the other’s intentions and actions, (2) commitment to the joint activity itself, (3) commitment to mutual support should the other be unable to perform their part. Each agent’s intentions are recursively nested in the other’s. Distinguishes genuine cooperation from coincident individually-rational action; foundation of joint-intention models in MAS.

In this vault

Two Faces of Intention

Reference: Bratman, M. E. (1984). The Philosophical Review, 93(3), 375–405. Source file: bratman_two_faces_of_intention.pdf. URL

Summary

Bratman’s canonical statement of the planning theory of intention. He argues that commonsense psychology uses “intention” to characterise both actions (done intentionally) and mental states (intending to act), and that neither the desire-belief reductionist model (Davidson) nor the Simple View (to A intentionally I must intend to A) correctly captures the two faces. Instead, intentions are distinctive, irreducible states of mind that function as elements of partial, future-directed plans which coordinate conduct over time and with other agents.

Because intentions serve as inputs to further means-end reasoning and as filters on admissible options, they must satisfy internal and means-end consistency constraints; but they need not entail all their foreseen consequences as further intentions. Bratman develops the distinction between what one intends and the motivational potential of an intention (foreseen but unintended side-effects that one is nonetheless prepared to bring about), which dissolves classic puzzles about double effect without collapsing into the Simple View. The methodological priority of future-directed intention — intentions as ingredients of plans — became the philosophical foundation for the BDI architecture in AI.

Key Ideas

Two faces: intentional action vs. intending (present- vs. future-directed).
Rejection of the Desire-Belief reductive model.
Rejection of the Simple View (intentional A-ing requires intending to A).
Intentions as partial plans coordinating activity over time.
Plan-consistency, means-end coherence, non-reconsideration norms.
Distinction: what one intends vs. motivational potential (side effects).
Future-directed intention has methodological priority.

Connections

Conceptual Contribution

Claim: Intentions cannot be reduced to configurations of belief and desire; they are distinctive planning states whose function is to stabilise and coordinate future action, and the two uses of “intention” (for acts and for mental states) are united through the common role of such planning states rather than through an identity of content.
Mechanism: Bratman argues against the Desire-Belief Model by showing planning creatures settle in advance on options that beliefs+desires underdetermine; against the Simple View by exhibiting cases where A is done intentionally without intending-to-A (e.g., foreseen side effects one is willing to accept). He replaces both with the Single Phenomenon View refined by a plan-theoretic account: intentions are inputs to further reasoning, demand consistency and means-end coherence, resist easy reconsideration, and possess motivational potential beyond strict intended content.
Concepts introduced/used: Intention, Planning Theory of Intention, Practical Reasoning, Motivational Potential, Future-Directed Intention, Simple View, Single Phenomenon View
Stance: philosophical theory
Relates to: Philosophical foundation cited and formalised by Intention Is Choice with Commitment and Modeling Rational Agents within a BDI-Architecture; supplies the mentalistic vocabulary surveyed in Intelligent Agents Theory and Practice and operationalised in Agent-Oriented Programming; complements the external ascription view of Intentional Stance.

Tags

Constraint Store

In Concurrent Constraint Programming, the shared monotonically-growing collection of partial-information constraints over shared variables that serves as the medium of inter-agent communication. Reading is by entailment query (ask c ⊃ P blocks until the store entails c); writing is by constraint addition (tell c → P, asynchronous). Information accumulates and is never retracted — the monotonicity discipline that makes CCP reason-friendly and intrinsically coordination-free.

In this vault

Ask-Tell

The two communication primitives of Concurrent Constraint Programming. Tell c → P (Saraswat’s atomic tell) adds constraint c to the constraint store if it is consistent with what is already there, then continues as P; the simpler eventual tell variant adds unconditionally without consistency-checking. Ask c ⊃ P blocks until the store entails c, then continues as P — synchronous on entailment. All other concurrency operators (parallel composition, choice, hiding, recursion) are built from ask, tell, and the algebraic structure of the constraint system.

In this vault

Concurrent Constraint Programming

Saraswat’s (1989) framework unifying concurrent computation, constraint solving, and declarative logic programming. Agents communicate via a shared monotonically-growing constraint store using two primitives: tell (add a constraint, asynchronous) and ask (block until the store entails a query). Subsumes concurrent logic programming (Concurrent Prolog, GHC, Parlog), constraint logic programming (CLP), and process-calculus synchronisation patterns. Mozart/Oz is the canonical implementation.

In this vault

Jason (BDI runtime)

Bordini, Hübner & Wooldridge’s (2007) Java-based interpreter for an extended AgentSpeak language — the most-deployed BDI agent platform in academic MAS research. Adds internal actions, customisable selection functions, plan annotation, and integration with JaCaMo (CArtAgO artefacts + MOISE organisations). Used as the standard testbed in many MAS research papers and as the implementation substrate of several agent-coordination projects.

In this vault

AgentSpeak

Rao’s (1996) operational BDI agent programming language: an agent is a triple of belief base (Prolog facts), plan library (event-triggered procedures), and intention stack (plans-in-execution). The interpreter cycles through perceive → event-generate → plan-select → execute. Eight-rule SOS-style operational semantics fits on a page. Made practically dominant through Jason (Bordini-Hübner-Wooldridge 2007), the most-deployed BDI platform in academic MAS research.

In this vault

Modeling Rational Agents within a BDI-Architecture

Reference: Rao, A. S., & Georgeff, M. P. (1991). In J. Allen, R. Fikes, & E. Sandewall (Eds.), Proceedings of the Second International Conference on Principles of Knowledge Representation and Reasoning (KR’91), 473–484. Morgan Kaufmann. Also AAII Technical Note 14. Source file: rao_georgeff_bdi_architecture.pdf. URL

Summary

Rao and Georgeff give the canonical formalization of the Belief–Desire–Intention architecture as a modal/temporal logic over a branching-time possible-worlds model (a first-order extension of CTL*). Beliefs, goals (chosen, consistent, believed-achievable desires), and intentions are each modelled as accessibility relations over time trees, with the crucial innovation that belief-, goal-, and intention-accessible worlds are themselves time trees rather than static worlds — so an agent’s mental state simultaneously ranges over uncertainty about the world (branches across belief-worlds) and choice among options (branches within each world).

The paper realises the central tenets of Bratman’s philosophical theory (intentions as partial plans, irreducible to belief+desire) in a tractable semantic framework and introduces the distinction between choice (what the agent picks) and possibility (what the environment affords). A key technical contribution is the family of commitment strategies — blind, single-minded, and open-minded — which parametrically define how intentions persist under changing beliefs, yielding a taxonomy of rational agent types from fanatically committed to fully reconsidering. The formalism relates intentions to actions via sub-world inclusion (goals ⊆ beliefs; intentions ⊆ goals), avoiding classical side-effect problems of earlier intention logics.

Key Ideas

First-order CTL*-based modal logic with Bel, Goal, Intend accessibility.
Belief-, goal-, intention-accessible worlds are themselves branching time trees.
Optional vs. inevitable path modalities; distinguishes choice from possibility.
Strong realism constraint: goal-worlds are sub-worlds of belief-worlds.
Commitment strategies: blind, single-minded, open-minded.
Intentions treated as first-class, non-reducible to beliefs and desires.
Comparison with Cohen–Levesque’s reductive intention formalism.

Connections

Conceptual Contribution

Claim: Rational agent behaviour is best modelled by treating beliefs, goals and intentions as equally fundamental modal attitudes over branching time, with agent types differentiated by commitment strategy rather than by reduction of intention to other attitudes.
Mechanism: (i) Adopt CTL*-style branching time where each situation is a time point in a time tree, with path modalities optional and inevitable; (ii) associate each situation with sets of belief-, goal-, and intention-accessible worlds, each itself a time tree, imposing sub-world containment (strong realism); (iii) define rationality postulates relating the three attitudes; (iv) axiomatise commitment policies (blind = drop intention only on achievement, single-minded = also drop when no longer believed achievable, open-minded = also drop when no longer desired), yielding distinct agent classes.
Concepts introduced/used: BDI Logic, Commitment Strategies, Strong Realism, Branching Time, Intention, Practical Reasoning
Stance: formal framework
Relates to: Formalises the philosophical picture of Two Faces of Intention and operationalises the stance of Intentional Stance; provides the semantic bedrock for BDI Architecture, Agent-Oriented Programming and the theory side of Intelligent Agents Theory and Practice; differs from and complements Intention Is Choice with Commitment (Cohen & Levesque) by treating intention as primitive rather than derived.

Tags

Generality in Artificial Intelligence

Reference: John McCarthy (1987). “Generality in Artificial Intelligence.” Communications of the ACM 30(12): 1030-1035. Rewritten and expanded version of McCarthy’s 1971 ACM Turing Award Lecture of the same title (the original 1971 version was never published to his satisfaction). Source file: mccarthy-generality.pdf. URL

Summary

McCarthy’s Turing Award reflection, revised sixteen years later. He opens by admitting that the original 1971 Turing lecture was “overambitious” — he could not then state his thoughts on generality in a satisfactory written form — and that the problem of generality in AI is “almost as unsolved as ever,” though with more ideas now available. The paper is his summary diagnosis of why AI programs in 1987 still lack general intelligence and a short catalogue of research directions that might help.

The lead diagnosis: AI programs have no general database of common-sense knowledge that any program could draw on. A small addition to what a program is supposed to do typically requires a complete rewrite starting with the data structures; modifying search strategies is even harder. The key missing piece is a language for expressing general common-sense knowledge that can be included in a database shared across programs. McCarthy then surveys candidate approaches — Friedberg-style program-modification learning (too unstructured), GPS and SOAR (domain-independent problem solving, but failed to be truly general), rule-based expert systems, neural networks, first-order logic plus situation calculus, circumscription and non-monotonic reasoning, frames, scripts — and evaluates each against the generality criterion.

The paper culminates in a re-statement of McCarthy’s logicist agenda: generality will come from treating common-sense knowledge as a formal database in first-order logic (augmented with circumscription for defaults and with concepts-as-individuals for propositional attitudes), designed so that programs consult this database rather than having it compiled into their structure. It is the closest thing to a mature manifesto of McCarthy’s research programme and is continually cited as the articulation of what “logicist AI” means.

Key Ideas

Generality is the unsolved problem of AI: small changes to a problem should require small changes to the program, and a shared common-sense database should be useable by any program that needs it.
The primary obstacle is that existing AI programs bake their knowledge into data structures and control flow rather than consulting a shared declarative database.
Friedberg-style program-mutation learning is representationally general but practically barren.
GPS / SOAR separate goals and subgoals from the domain but fail on problems whose solutions require common-sense knowledge not reducible to state-transformation rules.
Expert systems are narrow by design.
The logicist approach — first-order logic + situation calculus + circumscription + concepts-as-individuals — is defended as the most promising route to a language for general common-sense knowledge.
The frame problem, qualification problem, and ramification problem are all facets of the generality problem.
Elaboration tolerance: the measure of a representation’s generality is how small the elaborations required by new information are.

Connections

Programs with Common Sense — the 1959 origin of the programme this paper summarises.
Recursive Functions of Symbolic Expressions and Their Computation by Machine
Some Philosophical Problems from the Standpoint of Artificial Intelligence
Epistemological Problems of Artificial Intelligence
Circumscription - A Form of Nonmonotonic Reasoning
Circumscription - Applications to Formalizing Common Sense Knowledge
Ascribing Mental Qualities to Machines
First Order Theories of Individual Concepts and Propositions
Towards a Mathematical Science of Computation
Correctness of a Compiler for Arithmetic Expressions
Elephant 2000 - A Programming Language Based on Speech Acts
Common Business Communication Language
Common Sense Reasoning
Knowledge Representation
Non-monotonic Reasoning
Circumscription
Epistemic Logic
The Knowledge Level — Newell’s parallel statement of the same ambition.
The Society of Mind — Minsky’s alternative (procedural, multi-agent) answer to the generality problem.
Formal Verification

Conceptual Contribution

Claim: The central unsolved problem of AI is generality — how to write programs whose small extensions require only small modifications, and how to share a database of common-sense knowledge across programs. The most promising route is logicist: first-order logic, situation calculus, circumscription, and concepts-as-individuals, combined so that programs consult a declarative common-sense database rather than embedding knowledge in code.
Mechanism: Argumentative / programmatic. Surveys candidate approaches (program-mutation learning, GPS/SOAR, production rules, frames, logic) against a generality criterion (small change of problem → small change of program; database usable across programs). Re-asserts the logicist stack as the best match.
Concepts introduced/used: Generality, Elaboration Tolerance, Common Sense Database, Frame Problem, Qualification Problem, Ramification Problem, Logicist AI, Circumscription, Concepts as Individuals.
Stance: manifesto / methodological
Relates to: Summarises and defends the programme whose parts are worked out in Programs with Common Sense, Some Philosophical Problems from the Standpoint of Artificial Intelligence, Epistemological Problems of Artificial Intelligence, Circumscription - A Form of Nonmonotonic Reasoning, Circumscription - Applications to Formalizing Common Sense Knowledge, Ascribing Mental Qualities to Machines, and First Order Theories of Individual Concepts and Propositions. Methodologically parallel to The Knowledge Level; counterposed to The Society of Mind.

Circumscription - Applications to Formalizing Common Sense Knowledge

Circumscription — Applications to Formalizing Common Sense Knowledge

Reference: John McCarthy (1986). “Applications of Circumscription to Formalizing Common Sense Knowledge.” Artificial Intelligence 28(1): 89-116. Source file: mccarthy-applications1986.pdf. Sequel to the 1980 paper; see Circumscription - A Form of Nonmonotonic Reasoning for the original formulation and motivation. URL

Summary

The 1986 sequel that supersedes the technical machinery of McCarthy’s 1980 Circumscription paper. Where the 1980 paper introduced predicate and domain circumscription as rules of conjecture for handling the qualification problem, this paper presents a new, more symmetric version — now called formula circumscription — and shows how it, together with a uniform abnormality predicate ab, can formalise a wide range of common-sense reasoning tasks: is-a hierarchies with exceptions, the unique-names hypothesis, the frame problem (via circumscribing abnormality-of-fluents rather than asserting individual frame axioms), and defeasible defaults.

The central methodological move is to express a typical common-sense rule as “normally, P” — formalised as ∀x. ¬ab(aspect₁(x)) ⊃ P(x) — and then circumscribe ab relative to the known facts, with certain other predicates and functions allowed to vary during the minimisation. Allowing predicates other than the one being minimised to vary was the key technical gap in the 1980 formulation; it is what lets circumscription express the frame problem properly (the ab predicate is circumscribed while the fluent values are varied), and what makes prioritised and parallel circumscriptions possible. Birds-fly/Tweety, blocks-on-blocks, and other benchmark examples are worked out in detail.

Alongside Ascribing Mental Qualities to Machines and First Order Theories of Individual Concepts and Propositions, this is the paper that consolidates McCarthy’s logicist programme for common-sense knowledge into a concrete technical agenda: formalise in sorted first-order logic, add concepts-as-individuals where modality is needed, use circumscription (over ab) to handle defaults and the frame problem, and build large reusable common-sense databases. It is the paper cited in the ACL/agent-communication literature whenever “McCarthy on circumscription” is invoked as a foundation for defeasible agent reasoning.

Key Ideas

Formula circumscription generalises predicate circumscription: circumscribe a formula with some predicates and functions allowed to vary.
The abnormality predicate ab provides a uniform idiom: “normally P” becomes ¬ab(aspect(x)) ⊃ P(x), and the formalisation is combined with ab being circumscribed.
Solves the frame problem via circumscribing ab(aspect, action, fluent, situation) while letting the fluents vary — no more individual frame axioms per (action, fluent) pair.
Is-a hierarchies with exceptions: “birds fly except when abnormal”, cancellation of inheritance via ab.
Unique-names hypothesis stated and circumscribed in the same framework.
Prioritised circumscription briefly explored: minimise one abnormality before another.
Supersedes the 1980 paper; references in the literature “to this paper only would better refer to the latter paper in addition or to the latter paper only” (quoting McCarthy on the 1980 paper’s jmc.stanford.edu page).

Connections

Circumscription - A Form of Nonmonotonic Reasoning — the 1980 original, whose formalism this paper supersedes while retaining its motivation.
Programs with Common Sense
Recursive Functions of Symbolic Expressions and Their Computation by Machine
Some Philosophical Problems from the Standpoint of Artificial Intelligence — names the frame problem solved (or at least much reduced) here.
Epistemological Problems of Artificial Intelligence
Ascribing Mental Qualities to Machines
First Order Theories of Individual Concepts and Propositions
Generality in Artificial Intelligence
Towards a Mathematical Science of Computation
Correctness of a Compiler for Arithmetic Expressions
Elephant 2000 - A Programming Language Based on Speech Acts
Common Business Communication Language
Common Sense Reasoning
Knowledge Representation
Non-monotonic Reasoning
Circumscription
Epistemic Logic
The Knowledge Level
The Society of Mind
Formal Verification
Frame Problem

Conceptual Contribution

Claim: Common-sense knowledge — including default rules, is-a hierarchies with exceptions, the unique-names hypothesis, and (most importantly) the frame problem — can be uniformly formalised by expressing “normally P” as ¬ab(aspect) ⊃ P, then circumscribing ab while allowing other relevant predicates and functions to vary. This formula circumscription supersedes the 1980 predicate/domain circumscription.
Mechanism: Formula circumscription schema: given A(P;Q) with P minimised and Q varied, conjoin the second-order sentence stating that no smaller assignment to P (with Q varied accordingly) satisfies A. Reduce A to first-order form in cases where second-order quantifiers can be eliminated. Uniform use of ab(aspectᵢ(x)) to carry all defeasibility. Prioritised circumscription for ordering defaults.
Concepts introduced/used: Formula Circumscription, Abnormality Predicate, Frame Problem, Default Reasoning, Is-a Hierarchy, Unique Names Hypothesis, Prioritised Circumscription, Non-monotonic Reasoning, Circumscription.
Stance: foundational
Relates to: Supersedes Circumscription - A Form of Nonmonotonic Reasoning; provides the defeasibility infrastructure on which Elephant 2000 - A Programming Language Based on Speech Acts and Common Business Communication Language implicitly rely; one of the three McCarthy pillars alongside Ascribing Mental Qualities to Machines and First Order Theories of Individual Concepts and Propositions; technically addresses the frame problem named in Some Philosophical Problems from the Standpoint of Artificial Intelligence and the default-reasoning open problems listed in Epistemological Problems of Artificial Intelligence.

Circumscription - A Form of Nonmonotonic Reasoning

Circumscription — A Form of Non-Monotonic Reasoning (1980)

Reference: John McCarthy (1980). “Circumscription — A Form of Non-Monotonic Reasoning.” Artificial Intelligence 13(1-2): 27-39. The author-hosted PDF (2004 reformatting) adds a 1996 addendum; file is mccarthy-circumscription1980.pdf. Disambiguated from the 1986 sequel Circumscription - Applications to Formalizing Common Sense Knowledge which introduces formula circumscription and the abnormality predicate. URL

Summary

McCarthy’s landmark treatment of the qualification problem: any common-sense rule (e.g. “a rowboat can be used to cross a river”) is subject to an open-ended list of possible defeaters (no oars, a leak, cannibals, a sea monster) that cannot plausibly be enumerated in advance. Standard first-order logic is monotonic — adding premises never removes conclusions — so it cannot support the everyday inference “no defeater mentioned, therefore none present.”

Circumscription is a formally specified rule of conjecture that licenses jumping to the conclusion that the objects (or tuples) shown to satisfy a predicate P are the only ones that do. Adding a sentence “There is a bridge upstream” then legitimately retracts the original conclusion — non-monotonicity is thus built in at the rule-of-conjecture level, not by weakening the logic itself. The paper explains predicate circumscription, shows how domain circumscription (minimal inference) is a special case, works through the missionaries-and-cannibals puzzle to show how circumscription blocks sea-monster-style pedantry, and connects the technique to default reasoning (Reiter), to THNOT in MICROPLANNER (Sussman et al.), and to McCarthy’s broader project of formalising common-sense knowledge in logic.

Together with Ascribing Mental Qualities to Machines and First Order Theories of Individual Concepts and Propositions, this is one of the three pillars of McCarthy’s logicist programme. Its non-monotonic commitment is directly inherited by the CBCL proposal (partial-understanding messages) and by Elephant 2000’s treatment of commitments and speech-act preconditions.

Key Ideas

The qualification problem: common-sense rules have unbounded implicit preconditions that cannot be enumerated.
Monotonicity of FOL is the obstacle; circumscription is a rule of conjecture over FOL, not a modification of its proof theory.
Predicate circumscription: the tuples shown to satisfy P are all the tuples that do.
Domain circumscription (minimal inference) subsumed as a special case.
Non-monotonicity at the level of conjecture rather than entailment — new facts retract conjectures without breaking soundness of FOL.
“Common-sense knowledge must be expressed in a form that says a boat crosses rivers unless something prevents it” — ontology must admit prevention-entities.

Connections

Ascribing Mental Qualities to Machines — philosophical companion; circumscription is the formal tool for the ascriptive logicist programme argued for there.
First Order Theories of Individual Concepts and Propositions — shares the methodology of extending expressive power without abandoning first-order logic.
Common Sense Reasoning
Knowledge Representation
Elephant 2000 - A Programming Language Based on Speech Acts — Elephant’s commitments and speech-act preconditions are governed by defeasible, common-sense rules of exactly the kind circumscription was designed to formalise.
Foundations of Logic Programming - Lloyd — negation-as-failure in logic programming is a close cousin of circumscription.
Common Business Communication Language — CBCL’s ADJECTIVE construct and partial-understanding fallback are predicated on non-monotonic reading.

Conceptual Contribution

Claim: Common-sense reasoning requires non-monotonic inference, and this can be supplied to ordinary first-order logic by a rule of conjecture (circumscription) without modifying the logic itself.
Mechanism: Predicate circumscription schema: from a set of facts A mentioning P, conjecture that the only tuples satisfying P are those whose satisfaction follows from A. Domain circumscription as minimal-model inference. Combination with ordinary FOL rules of inference. Explicit introduction into the ontology of prevention-entities (“something wrong with the boat”).
Concepts introduced/used: Circumscription, Non-monotonic Reasoning, Qualification Problem, Default Reasoning, Minimal Model, Common Sense Reasoning, Rule of Conjecture.
Stance: foundational
Relates to: One of the three McCarthy pillars alongside Ascribing Mental Qualities to Machines and First Order Theories of Individual Concepts and Propositions; provides the defeasibility semantics that Elephant 2000 - A Programming Language Based on Speech Acts needs for commitment revision and Common Business Communication Language needs for partial-understanding messaging.

Epistemological Problems of Artificial Intelligence

Reference: John McCarthy (1977). “Epistemological Problems of Artificial Intelligence.” In Proceedings of the 5th International Joint Conference on Artificial Intelligence (IJCAI-77), Cambridge, MA, pp. 1038-1044. IJCAI Computers and Thought Award Lecture. Source file: mccarthy-epistemological.pdf. URL

Summary

McCarthy’s IJCAI-77 invited lecture returns to the division of AI into epistemological and heuristic parts first drawn in Some Philosophical Problems from the Standpoint of Artificial Intelligence, and explains, eight years later, what the epistemological part actually studies: what kinds of facts about the world are available to an observer with given opportunities to observe, how these facts can be represented in the memory of a computer, and what rules permit legitimate conclusions to be drawn from them. Heuristics — how to search the space of possibilities — is deliberately bracketed.

The paper defends first-order logic as the right epistemological medium, introducing a key move: treating individual concepts as objects inside first-order logic so that modal phenomena (knowledge, belief, necessity) can be axiomatised without leaving the first-order setting — a move fully developed in First Order Theories of Individual Concepts and Propositions. McCarthy then formulates a precise criterion for epistemological adequacy: a theory is epistemologically adequate iff a robot whose database contains it, and which emits X just in case “I should emit output X now” is a logical consequence of its database, could in principle achieve its goals — irrespective of how fast the program runs. A theory that satisfies this but has no feasible proof search is heuristically inadequate. Most existing AI formalisms, he argues, fail the epistemological criterion — they are too narrow, too procedural, or too entangled with implementation.

The body of the paper surveys concrete epistemological problems: partial information, the representation of other agents’ knowledge, reasoning about one’s own ability, defaults (anticipating circumscription), temporal projection, and knowing what vs knowing that. It is the most concise and programmatic statement of the logicist agenda McCarthy pursued from 1959 through the 1980s, and it is the methodological ancestor of The Knowledge Level — Newell’s roughly contemporaneous reframing of the same distinction in terms of agents that are characterised solely by their knowledge and goals.

Key Ideas

Epistemological problems of AI — what can be known, how it is represented, what inferences are licensed — are studied separately from heuristic problems of search.
First-order logic with concepts as individuals (not modal operators) is the proposed medium for expressing partial knowledge, belief, and necessity.
Precise epistemological adequacy criterion: the theory suffices iff a robot emitting whatever sentences of the form “I should emit X now” are logical consequences of its database could achieve its goals given unbounded computation.
Heuristic adequacy is a separate requirement; a theory may be epistemologically adequate but practically useless.
Most current AI formalisms (MICROPLANNER, pattern-invocation systems, production rules) trade epistemological adequacy for heuristic adequacy — a premature optimisation.
Defaults, counterfactuals, self-knowledge, knowing-what vs knowing-that are identified as open epistemological problems.
The spectrum from logic-as-data through compiled / hardware-embedded knowledge — each step trades declarative generality for heuristic speed.

Connections

Programs with Common Sense
Recursive Functions of Symbolic Expressions and Their Computation by Machine
Some Philosophical Problems from the Standpoint of Artificial Intelligence — source of the epistemological/heuristic division refined here.
Circumscription - A Form of Nonmonotonic Reasoning — later technical answer to the default-reasoning problems this paper names.
Ascribing Mental Qualities to Machines — philosophical companion argued in parallel.
First Order Theories of Individual Concepts and Propositions — formal execution of the concepts-as-individuals move sketched here.
Generality in Artificial Intelligence
Towards a Mathematical Science of Computation
Correctness of a Compiler for Arithmetic Expressions
Elephant 2000 - A Programming Language Based on Speech Acts
Common Business Communication Language
Common Sense Reasoning
Knowledge Representation
Non-monotonic Reasoning
Epistemic Logic
The Knowledge Level — Newell’s parallel knowledge-level formulation.
The Society of Mind — Minsky’s opposing procedural / agent-based stance on the same questions.
Formal Verification — the epistemological-adequacy criterion is structurally analogous to logical completeness for specifications.

Conceptual Contribution

Claim: AI should separate epistemological adequacy (can the theory in principle drive correct action?) from heuristic adequacy (can the proof search be carried out fast enough?); most current AI formalisms have sacrificed the former for the latter, and progress requires re-asserting the epistemological standard — via first-order logic augmented with concepts-as-individuals.
Mechanism: The robot-with-a-database thought experiment: a system whose inputs become sentences in its database and which emits X iff "I should emit X now" is a logical consequence of its database. A theory is epistemologically adequate iff such a system could achieve its goals given unbounded time. This separates content of knowledge from efficiency of inference.
Concepts introduced/used: Epistemological Adequacy, Heuristic Adequacy, Concepts as Individuals, Knowledge Representation, Default Reasoning, Partial Information, First-Order Logic.
Stance: methodological / foundational
Relates to: The methodological backbone of the logicist programme — continued from Some Philosophical Problems from the Standpoint of Artificial Intelligence into First Order Theories of Individual Concepts and Propositions and Circumscription - A Form of Nonmonotonic Reasoning; its epistemological/heuristic distinction is the same divide that The Knowledge Level articulates from a different angle, and that The Society of Mind rejects by identifying knowledge with procedure.

Some Philosophical Problems from the Standpoint of Artificial Intelligence

Reference: John McCarthy and Patrick J. Hayes (1969). “Some Philosophical Problems from the Standpoint of Artificial Intelligence.” In B. Meltzer and D. Michie (eds.), Machine Intelligence 4, Edinburgh University Press, pp. 463-502. Source file: mccarthy-mcchay69.pdf. URL

Summary

The paper that introduces situation calculus, names the frame problem, and divides AI cleanly into an epistemological part (what can in principle be inferred from what is knowable about the world) and a heuristic part (how to search that space efficiently). McCarthy and Hayes argue that a program capable of acting intelligently in the world must have a general representation of the world, and that designing such a representation forces the AI researcher to confront traditional philosophical problems — causality, ability, knowledge, free will, counterfactuals — with unusual rigor, because the representation has to be complete enough to drive actual deduction.

The paper is in four parts. Part 1 is philosophical: metaphysically vs epistemologically adequate representations, a proposed resolution of free will in a deterministic universe (via the existence of alternatives that the agent can bring about in its coarser theory), and a treatment of counterfactuals. Part 2 is the formal core: situations as complete states of the universe, fluents as functions on situations, actions as functions from situation to situation with result(a, s), and a method of constructing first-order sentences true exactly when a strategy achieves a goal. Part 3 surveys open problems, most famously the frame problem: how to state concisely what does not change when an action is performed, without writing an axiom for every (action, fluent) pair. Part 4 reviews philosophical logic in relation to AI.

This is the paper that makes temporal / action reasoning a first-class topic in AI. Its ontology of situations, fluents, actions, and result is the direct ancestor of every subsequent theory of action — STRIPS, event calculus, fluent calculus, BDI temporal logics, ConGolog, planning formalisms, and the temporal backbone of Ensuring Trustworthy and Ethical Behaviour in Intelligent Logical Agents. The epistemological/heuristic distinction is picked up again in Epistemological Problems of Artificial Intelligence (1977) and shapes the methodology of logicist AI.

Key Ideas

Epistemological vs metaphysical adequacy of representations: a representation is epistemologically adequate if an observer can in practice express what they can come to know, not just what is ultimately true.
Situation calculus: situations as complete states, fluents as situation-parametrised functions/predicates (e.g., at(x, s)), actions as functions result(a, s).
The frame problem: stating concisely what is unchanged by an action; a foundational difficulty for any action-based formalism.
The qualification problem (in embryo): actions have open-ended preconditions that cannot all be enumerated — later treated in Circumscription - A Form of Nonmonotonic Reasoning.
can, causes, and knows reduced to first-order formulations over situations and strategies, including strategies with loops and knowledge acquisition.
Free will and counterfactuals reinterpreted via alternative strategies available in an agent’s coarser (epistemologically adequate) theory — not by denying determinism.
Division of AI into epistemological and heuristic parts; the paper concentrates on the former.

Connections

Programs with Common Sense — the 1959 predecessor; this paper repairs its treatment of action and time.
Recursive Functions of Symbolic Expressions and Their Computation by Machine
Epistemological Problems of Artificial Intelligence — continues the epistemological-adequacy programme.
Circumscription - A Form of Nonmonotonic Reasoning — formal answer to the qualification problem raised here.
Ascribing Mental Qualities to Machines
First Order Theories of Individual Concepts and Propositions
Generality in Artificial Intelligence
Towards a Mathematical Science of Computation
Correctness of a Compiler for Arithmetic Expressions
Elephant 2000 - A Programming Language Based on Speech Acts
Common Business Communication Language
Common Sense Reasoning
Knowledge Representation
Non-monotonic Reasoning
Epistemic Logic
The Knowledge Level
The Society of Mind
Frame Problem
Situation Calculus
Ensuring Trustworthy and Ethical Behaviour in Intelligent Logical Agents — A-ILTL’s temporal obligations inherit the situation-calculus transition structure.
BDI — BDI logics (Rao & Georgeff, Cohen & Levesque) build their belief/desire/intention modalities on top of situation-calculus-style branching time.
BDI Logic

Conceptual Contribution

Claim: AI requires an epistemologically adequate representation of the world, which forces the AI researcher to solve philosophical problems (causality, ability, knowledge, counterfactuals, free will) formally; situation calculus — situations, fluents, actions with result(a, s) — provides a first-order representation in which strategies achieving goals can be proved correct.
Mechanism: First-order logic with sorted terms for situations, fluents, and actions; the result function; axioms expressing action effects and successor-state relations; proof-of-strategy construction; explicit treatment of knowledge strategies (plans involving learning what one does not yet know); methodological division of AI into epistemological and heuristic parts.
Concepts introduced/used: Situation Calculus, Fluent, Frame Problem, Qualification Problem, Epistemological Adequacy, Metaphysical Adequacy, Counterfactual, Action Formalism, Planning, Knowing How vs Knowing That.
Stance: foundational
Relates to: Names the frame problem that every subsequent action formalism must address; furnishes the ontology that BDI logics and Ensuring Trustworthy and Ethical Behaviour in Intelligent Logical Agents inherit for their temporal/intentional semantics; sets up the qualification problem that Circumscription - A Form of Nonmonotonic Reasoning later solves; methodologically complements Ascribing Mental Qualities to Machines and First Order Theories of Individual Concepts and Propositions; the epistemological-adequacy criterion reappears explicitly in Epistemological Problems of Artificial Intelligence.

Recursive Functions of Symbolic Expressions and Their Computation by Machine

Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I

Reference: John McCarthy (1960). “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I.” Communications of the ACM 3(4): 184-195. (Author-hosted LaTeX reformatting with minor notational changes.) Source file: mccarthy-recursive.pdf. URL

Summary

The Lisp paper. McCarthy describes a programming system — LISP, for LISt Processor — developed for the IBM 704 at MIT, originally designed to support the advice taker of Programs with Common Sense by giving it a substrate for manipulating symbolic (declarative and imperative) sentences. The system evolved into a representation of partial recursive functions over a class of symbolic expressions (S-expressions) whose elegance transcended its motivating application. The paper presents S-expressions, a small set of elementary S-functions (atom, eq, car, cdr, cons), conditional expressions (newly introduced here), recursive function definitions via a λ-calculus-flavored notation, and the universal S-function apply that plays the role of a universal Turing machine and the practical role of an interpreter — the now-iconic code-is-data eval/apply kernel.

The paper then translates this formalism into IBM 704 list structures (the famous CAR/CDR naming reflecting the 704’s address and decrement register fields), describes the main features of the LISP system (garbage collection, interpreter, compiler sketch, free storage), and gives a recursive-function interpretation of flow charts — i.e., a semantics for imperative programs via recursive functions, anticipating much later work on denotational semantics. Conditional expressions, submitted by McCarthy as a letter to CACM and “demoted to a letter” by its editor (notes the footnote), were the notation Algol 60 then rejected in favour of if ... then ... else.

Lisp is simultaneously an AI implementation vehicle and a theory of computation — and the paper’s code-is-data property (programs are S-expressions) is what seeded the Lisp extensibility tradition (macros, embedded DSLs) that later runs through The Extensible Language - Graham, Code as Data, Macros as Language Extension, and Creating Languages in Racket. McCarthy closes promising a Part II on symbolic applications and a companion paper applying the recursive-function formalism to mathematical logic and theorem proving — the latter effectively becoming Correctness of a Compiler for Arithmetic Expressions and Towards a Mathematical Science of Computation.

Key Ideas

S-expressions: uniform tree/list data structure for both programs and data (code-is-data).
Five primitive functions (atom, eq, car, cdr, cons) suffice to define all computable functions over S-expressions.
Conditional expressions (p1 → e1, ..., pn → en) as a first-class construct — introduced to computer science here.
Recursive function definitions and λ-notation for anonymous functions.
Universal function apply — a meta-circular evaluator — plays the role of a universal Turing machine and a working interpreter.
Partial functions are inherent to computation (non-termination) and must be handled explicitly.
Flow charts reinterpreted as recursive function applications — an early denotational-style semantics for imperative programs.
Garbage collection (the concept of automatic reclamation of unreferenced list cells) introduced in the implementation notes.

Connections

Programs with Common Sense — Lisp was originally designed to support the advice taker.
Some Philosophical Problems from the Standpoint of Artificial Intelligence
Epistemological Problems of Artificial Intelligence
Towards a Mathematical Science of Computation — continues the theory-of-computation programme.
Correctness of a Compiler for Arithmetic Expressions — first proof of program correctness uses Lisp-like semantics.
First Order Theories of Individual Concepts and Propositions
Ascribing Mental Qualities to Machines
Circumscription - A Form of Nonmonotonic Reasoning
Generality in Artificial Intelligence
Elephant 2000 - A Programming Language Based on Speech Acts
Common Business Communication Language
The Extensible Language - Graham — Graham’s manifesto for the Lisp extensibility culture.
Code as Data — the homoiconicity principle first made concrete here.
Macros as Language Extension — macros exploit the S-expression representation of programs.
Creating Languages in Racket — modern Racket inherits eval/apply as the DSL substrate.
Lisp
Knowledge Representation
Common Sense Reasoning
An Unsolvable Problem of Elementary Number Theory — Church 1936, the λ-calculus whose notation McCarthy adapts for anonymous functions.
General Recursive Functions of Natural Numbers — Kleene 1936, the partial-recursive-function framing Lisp realises over S-expressions.

Conceptual Contribution

Claim: Partial recursive functions over symbolic expressions can be defined with five primitive operators (atom, eq, car, cdr, cons) plus conditional expressions and recursion, yielding a language in which programs are themselves symbolic expressions and a single universal function apply serves as both a universal Turing machine and a working interpreter — giving a uniform substrate for AI, programming, and the theory of computation.
Mechanism: S-expressions (atomic symbols + dotted pairs, list sugar); five primitives; conditional expression (p → e, ...); recursive function definitions; λ-notation; universal apply(f, args); IBM 704 list-structure implementation; garbage collection; recursive-function semantics of flow charts.
Concepts introduced/used: Lisp, S-expression, Conditional Expression, Recursive Function, Code as Data, Homoiconicity, eval apply, Garbage Collection, Meta-circular Evaluator.
Stance: foundational
Relates to: The implementation substrate that Programs with Common Sense anticipated. Its code-is-data property seeds the extensibility tradition — The Extensible Language - Graham, Macros as Language Extension, Creating Languages in Racket — and its apply formalism is the ancestor of denotational semantics used in Correctness of a Compiler for Arithmetic Expressions and Towards a Mathematical Science of Computation.

Programs with Common Sense

Reference: John McCarthy (1959). “Programs with Common Sense.” In Proceedings of the Teddington Conference on the Mechanization of Thought Processes, pp. 75-91. London: Her Majesty’s Stationery Office. Reprinted in Marvin Minsky (ed.), Semantic Information Processing, MIT Press, 1968, and in McCarthy’s Formalizing Common Sense (Ablex, 1990). Source file: mccarthy-mcc59.pdf. URL

Summary

The founding manifesto for knowledge representation and for logic-based AI. McCarthy proposes the advice taker — a program that reasons by manipulating sentences in a formal language (essentially predicate calculus), takes in advice in the form of declarative sentences, and deduces its actions from its premises together with imperative sentences about what is wanted. The central criterion he names is that the program “will have common sense” just in case it automatically deduces for itself a sufficiently wide class of immediate consequences of anything it is told and of what it already knows.

The paper distinguishes teaching a machine by imperative sentences (fast, no prior knowledge needed) from teaching by declarative sentences (exploits prior knowledge, robust to order, robust to context changes), and stakes AI on the declarative side. It lists five conditions for human-level intelligence — generality of representation, simple expression of behavior changes, improvability of the improving mechanism, concepts of partial success, and the ability to form reusable subroutines — and then sketches the advice taker as a concrete attempt at the second. The paper closes with a famous worked example: getting from home to the airport, formalised in a predicate-calculus-like language with premises such as at(I, desk), at(desk, home), and action axioms, so that the advice taker can chain them into a plan. A discussion appendix (Bar-Hillel, Oliver Selfridge, Yehoshua Bar-Hillel again, McCarthy’s replies) is one of the earliest recorded methodological debates in AI.

Every subsequent McCarthy paper — Recursive Functions (1960), Situation Calculus (1969), Epistemological Problems (1977), Circumscription (1980), Ascribing Mental Qualities (1979) — is in some sense an attempt to repair, extend, or defend a weakness of the advice-taker programme first stated here. It is also the point of origin for the entire declarative / symbolic tradition that the ACL design literature inherits.

Key Ideas

A program has common sense iff it automatically deduces a sufficiently wide class of immediate consequences of what it is told plus what it already knows.
Knowledge should be represented as sentences in a formal language (predicate calculus), not baked into procedures.
Declarative vs imperative instruction: declarative scales, imperative is fast; the advice taker chooses declarative.
To learn something, a program must first be capable of being told it.
Five pre-conditions for general intelligence: arbitrary behavior representable, simple expressibility of changes, improvable improvement mechanism, partial-success concepts, reusable subroutines.
Worked airport example — the first substantive formalisation of a situated plan in logic.

Connections

Recursive Functions of Symbolic Expressions and Their Computation by Machine — Lisp, the implementation vehicle proposed for the advice taker.
Some Philosophical Problems from the Standpoint of Artificial Intelligence — 1969 elaboration, introducing situation calculus to repair the action formalisation.
Epistemological Problems of Artificial Intelligence — 1977 diagnosis of what has and has not worked.
Circumscription - A Form of Nonmonotonic Reasoning — needed to make advice-taker inference non-monotonic.
Ascribing Mental Qualities to Machines
First Order Theories of Individual Concepts and Propositions
Generality in Artificial Intelligence
Towards a Mathematical Science of Computation
Correctness of a Compiler for Arithmetic Expressions
Elephant 2000 - A Programming Language Based on Speech Acts
Common Business Communication Language
Common Sense Reasoning
Knowledge Representation
The Knowledge Level — Newell’s characterisation of the advice-taker programme as operating at the knowledge level.
The Society of Mind — Minsky’s later (and more sceptical) response to the logicist programme.
Epistemic Logic

Conceptual Contribution

Claim: An intelligent agent can be built by representing its world as sentences in a formal (predicate-calculus) language, letting it take advice in declarative form, and deducing actions as logical consequences of its premises together with sentences about what it wants — the criterion of intelligence being how wide a class of immediate consequences it can automatically derive.
Mechanism: The advice taker architecture: formal-language knowledge base; declarative input (“I am at my desk”); imperative input (“I want to be at the airport”); rules of inference (predicate-calculus-style); action-producing deductions; interaction with humans that add or retract premises.
Concepts introduced/used: Advice Taker, Common Sense Reasoning, Declarative Knowledge, Knowledge Representation, Logicist AI, Planning, Situated Action.
Stance: foundational / programmatic
Relates to: The origin document of the declarative / logicist tradition that Knowledge Representation and Common Sense Reasoning formalise. The advice-taker agenda is continued in Some Philosophical Problems from the Standpoint of Artificial Intelligence (situation calculus to model action), Epistemological Problems of Artificial Intelligence (methodological self-review), and Circumscription - A Form of Nonmonotonic Reasoning (non-monotonicity to handle the qualification problem inherent in declarative advice). Elephant 2000 - A Programming Language Based on Speech Acts and Common Business Communication Language are late-career revivals of the advice-taker vision applied to agent communication.

First Order Theories of Individual Concepts and Propositions

Reference: John McCarthy (1979b). “First Order Theories of Individual Concepts and Propositions.” In J. E. Hayes, D. Michie, and L. I. Mikulich (eds.), Machine Intelligence 9, Ellis Horwood, pp. 129-147. (Version fetched is the revised 2000 reprint.) URL

Summary

McCarthy argues that knowledge, belief, wanting, and necessity can be formalised in ordinary sorted first-order logic — without modal operators, quotation, or possible-worlds machinery — by admitting individual concepts as first-class objects alongside the things that reify them. Where Frege had distinguished sense (the concept) from reference (the denotation), and where Carnap, Church, and Montague responded by extending logic, McCarthy responds by keeping logic ordinary and adding a domain of concepts plus a denot function mapping concepts to their denotations.

Thus Mike is the concept of Mike, mike is Mike himself, Telephone Mike is the concept of Mike’s telephone number, and telephone mike is the number. Know(Pat, Telephone Mike) is the proposition that Pat knows Mike’s telephone number; true Know(Pat, Telephone Mike) asserts it. Extensionality is expressed by explicit axioms: Know is extensional in its first (knower) argument but not its second, which is precisely why substituting equal telephone numbers inside Know fails. The paper works through knowing what vs knowing that, iterated knowledge, non-denoting concepts (Pegasus), belief, wanting, existence (via an Exists predicate that does not presuppose existence of the concept’s referent), and necessity — all in sorted FOL, with standard model theory available to study which concept-spaces satisfy which axioms.

The paper is McCarthy’s most developed statement of his reificationist, logicist methodology for mental attitudes: rather than extend the logic, extend the ontology. This is directly the substrate Elephant 2000 uses when it talks about speech acts committing agents to propositions and referring to past events and future obligations.

Key Ideas

Reify concepts as objects in sorted FOL; no modal operators, no quotation.
denot function maps concepts to their referents; extensionality becomes an axiom about particular functions rather than a global property of the logic.
Know(P, X) is extensional in P (the knower) but not in X (the knowand), explaining failure of substitutivity for knowledge.
knowing what vs knowing that are distinct; both are expressible.
Non-existent referents (Pegasus) handled by denotes(X, x) predicate rather than denot function, and by Exists/exists pair.
Concept-valued variables, functions, and constants (capitalisation convention) vs object-valued lowercase counterparts.

Connections

Ascribing Mental Qualities to Machines — the philosophical sibling paper; this gives the logical machinery for the ascriptions argued for there.
Elephant 2000 - A Programming Language Based on Speech Acts — Elephant’s program variables can range over speech acts, propositions, and commitments; the concept/object distinction here is exactly what allows a program to refer to the fact that Pat was told X rather than just to X’s value.
Knowledge Representation
Common Sense Reasoning
KIF — KIF’s individuating of propositions and sentences as first-class objects follows this lineage.
Speech Act Theory

Conceptual Contribution

Claim: Propositional attitudes and modalities can be formalised in ordinary sorted first-order logic by admitting individual concepts (and propositions) as objects with a denot mapping to their referents — no modal operators or quotation required.
Mechanism: Sorted FOL; capitalised concept-valued terms vs lowercase denotation-valued terms; denot/denotes functions and predicates; extensionality stated per-predicate via axioms like denot P1 = denot P2 => denot Know(P1,X) = denot Know(P2,X); Exists/exists to handle non-denoting concepts; true Q to lift propositions to truth values.
Concepts introduced/used: Individual Concepts, Propositional Attitudes, Extensionality, Sense and Denotation, Knowing What vs Knowing That, Reification, Sorted Logic.
Stance: foundational
Relates to: Provides the ontology on which Elephant 2000 - A Programming Language Based on Speech Acts builds its program-as-speech-act semantics; complements the ascriptive stance of Ascribing Mental Qualities to Machines; technically prefigures the object-level treatment of sentences in KIF and the commitment semantics in Agent Communication And Institutional Reality.

Correctness of a Compiler for Arithmetic Expressions

Reference: John McCarthy and James Painter (1967). “Correctness of a Compiler for Arithmetic Expressions.” In Mathematical Aspects of Computer Science (Proc. Symposia in Applied Mathematics, vol. 19), American Mathematical Society, pp. 33-41. URL

Summary

The first published machine-checkable-style proof that a compiler is correct. McCarthy and Painter take a trivially small source language — arithmetic expressions over constants, variables, and binary + — and a trivially small target — a single-accumulator machine with li, load, sto, add — and prove by structural induction that compile(e,t) run on the target produces the same accumulator value as the source semantics value(e, xi), while preserving the contents of low-numbered registers that hold the program’s variables.

The paper is methodologically landmark rather than technically deep: it formalises abstract syntax with isconst/isvar/issum predicates and selectors s1/s2; defines source semantics denotationally via a recursive value function; gives the object language both analytic and synthetic syntaxes (so that the compiler can construct code while the interpreter can destructure it); introduces state vectors with c(x,eta) for contents and a(x,alpha,eta) for update; defines outcome as the fold of step over a program; and proves the decisive lemma outcome(p1*p2, eta) = outcome(p2, outcome(p1, eta)). Correctness is then stated as a partial-equality relation zeta1 =_A zeta2 — agreement on all registers except those in the scratch set A — and proved by induction on expression structure.

Key Ideas

Compiler correctness as a theorem provable by structural induction over abstract syntax.
Abstract syntax (predicates + selectors) as the mathematical object, with analytic/synthetic syntaxes mediating between interpreter and compiler.
Denotational source semantics via a value function; operational target semantics via step/outcome.
Partial equality =_A on state vectors — the scratch-register-agnostic equivalence needed to state the theorem.
Proof template transferable to richer compilers and machines — the intended contribution is methodological.

Connections

Towards a Mathematical Science of Computation — the companion manifesto paper; this is its concrete proof-of-concept.
Elephant 2000 - A Programming Language Based on Speech Acts — continues McCarthy’s conviction that programs should have mathematical semantics strong enough to support correctness proofs.
Foundations of Logic Programming - Lloyd — parallel project for declarative languages.
Knowledge Representation

Conceptual Contribution

Claim: Compiler correctness is a rigorous mathematical theorem, provable by structural induction once source and target are given abstract-syntax formalisations and denotational/operational semantics respectively.
Mechanism: Abstract analytic syntax with predicate/selector signatures; denotational value(e,xi); single-accumulator machine with analytic/synthetic syntax pair; state vectors with c (contents) and a (update); outcome(p,eta) defined by fold; decisive concatenation lemma; partial-equality relation =_A on state vectors; structural induction on expressions.
Concepts introduced/used: Abstract Syntax, State Vector, Compiler Correctness, Structural Induction, Program Verification, Denotational Semantics, Operational Semantics.
Stance: foundational
Relates to: Realises the program set out in Towards a Mathematical Science of Computation; template for every subsequent verified-compiler result (CompCert and descendants); the logical-specification-of-programs stance that Elephant 2000 extends to speech-act-embedded programs.

Tags

Towards a Mathematical Science of Computation

Reference: John McCarthy (1963). “Towards a Mathematical Science of Computation.” In Information Processing 1962: Proceedings of IFIP Congress 62, North-Holland, pp. 21-28. (Version fetched is the 1996 revised reprint.) URL

Summary

McCarthy’s IFIP 1962 address sketches what a mathematical science of computation should look like, by analogy with physics: starting from basic assumptions, one should be able to deduce the important properties of the entities the science deals with. He identifies those entities as problems, procedures, data spaces, programs (which are symbolic expressions representing procedures in particular languages), and computers (viewed as finite automata, but from a stored-program-plus-unbounded-storage perspective rather than a finite-state one).

The paper enumerates the kinds of facts one would like to derive — procedure equivalence, termination, compiler correctness, program transformation preserving semantics, lower bounds — and argues that Goedel’s incompleteness precludes a complete theory but a practically adequate one is feasible. McCarthy proposes an integer-free formalism, recursive definitions via conditional expressions (the paper is a locus classicus of if p then a else b as a mathematical notation), and recursion induction as a proof method. He closes by urging that debugging be replaced by machine-checked proofs of program correctness — a foundational statement of the program-verification agenda.

Key Ideas

Computation as a mathematical science with its own entities (problems, procedures, data spaces, programs, computers) distinct from automata theory.
Conditional expressions if p then a else b and recursion as the basis of a formal notation for defining functions.
Recursion induction as a proof technique for program equivalence.
Compiler correctness as a target theorem for the formalism.
Debugging should be supplanted by computer-checked correctness proofs — the founding manifesto of program verification.

Connections

Correctness of a Compiler for Arithmetic Expressions — the paired McCarthy–Painter paper that carries out the compiler-correctness proof sketched here.
Elephant 2000 - A Programming Language Based on Speech Acts — Elephant’s insistence that programs refer directly to past events and future commitments continues McCarthy’s project of giving programs a mathematical semantics amenable to proof.
Foundations of Logic Programming - Lloyd — shares the model-theoretic semantics-for-programs stance.
First Order Theories of Individual Concepts and Propositions
Knowledge Representation
An Unsolvable Problem of Elementary Number Theory — Church 1936, the undecidability bound McCarthy invokes as the horizon of a “practically adequate” theory.
General Recursive Functions of Natural Numbers — Kleene 1936, the recursive-function substrate underpinning McCarthy’s formalism.
Recursively Enumerable Sets of Positive Integers and Their Decision Problems — Post 1944, the unsolvability theory framing termination and decidability limits.

Conceptual Contribution

Claim: Computation admits a mathematical science in the physics sense: basic assumptions from which properties of procedures, programs, and computers can be deduced, with program-correctness proofs replacing debugging.
Mechanism: Abstract syntax of programs; conditional expressions and recursion as a core notation; state vectors for machines; recursion induction; an integer-free formalism avoiding the Mostowski-style reliance on arithmetic coding.
Concepts introduced/used: Conditional Expressions, Recursion Induction, Abstract Syntax, State Vector, Compiler Correctness, Program Verification, Data Spaces.
Stance: foundational
Relates to: Grounds the semantic-correctness agenda that Elephant 2000 later inherits; complements Correctness of a Compiler for Arithmetic Expressions; the appeal to mathematical logic rather than automata foreshadows the logicist program in Ascribing Mental Qualities to Machines and Circumscription - A Form of Nonmonotonic Reasoning.

Tags

Elephant 2000 - A Programming Language Based on Speech Acts

Elephant 2000: A Programming Language Based on Speech Acts

Reference: John McCarthy (1989, revised). Formal Reasoning Group, Stanford University. Source file: elephant.pdf. URL

“I meant what I said, and I said what I meant. / An elephant’s faithful, one hundred percent! / moreover, / An elephant never forgets!”

Summary

McCarthy proposes Elephant 2000, a speculative programming language whose inputs and outputs are speech acts — requests, questions, offers, acceptances, declinations, permissions, and promises — rather than ordinary I/O. A program’s correctness is then partly defined by the “happy performance” of those acts in Austin’s sense: answers must be truthful and responsive, promises must be kept, and the program must not accept what it has no authority to accept. The paper is an essay of seven design theses, most strikingly:

An Elephant program is itself a logical sentence (or syntactic sugar for one); its extensional correctness properties follow by logical consequence without a separate theory of programming à la Hoare.
Elephant programs do not need data structures: they can refer directly to the past (history of events and states), just as natural-language speakers do (“the passenger has a reservation iff she made one and hasn’t cancelled it”).
Programs have both input-output specifications (generalising illocutionary speech acts) and accomplishment specifications (generalising perlocutionary acts — what the program actually brings about in the world).
Commercial transactions exchange obligations; an Elephant program’s specification may include the fact that the obligation exchange happens as intended, again as a logical sentence.

McCarthy explicitly departs from Searle/Austin by taking a design stance (Dennett) on speech acts, introducing abstract performatives (including purely internal commitments the agent makes to itself) as a category of program event. The paper is the direct programming-language-side ancestor of modern Agent Communication Languages, Commitment-based Semantics, and Intent Formalization — all written a decade before the ACL field got going.

Key Ideas

Speech-act I-O language: programs communicate via request, question, offer, accept, decline, permission, promise, assertion, plus internal commitment
Program-as-logical-sentence: extensional properties are logical consequences, no Hoare axioms required
Direct reference to the past: no data structures, just history queries (has-reservation(psgr, flt) ≡ made-reservation ∧ ¬cancelled)
Illocutionary vs. perlocutionary specs: input-output (program’s own behaviour) vs. accomplishment (effects in the world)
Abstract performatives — internal commitments whose content is independent of outward expression
Obligation exchange as a first-class specification element for commercial/institutional programs
Takes a design stance on speech acts — adapts Austin/Searle rather than inheriting them
Authority / permission / obligation are specification concerns: the program need not be conscious of them
Explicit claim: deliberately non-AI — Elephant usages that do not require intelligence are the focus

Connections

Ascribing Mental Qualities to Machines — McCarthy’s prior paper on when it’s useful to ascribe beliefs/intentions to programs
Common Business Communication Language — McCarthy 1982, explicitly cited as the motivating application
Towards a Mathematical Science of Computation — McCarthy 1963; originates the program-as-logical-object agenda Elephant radicalises.
Correctness of a Compiler for Arithmetic Expressions — McCarthy & Painter 1967; first proof-of-concept for the verification programme Elephant extends to speech-act semantics.
First Order Theories of Individual Concepts and Propositions — McCarthy 1979; the logical machinery for propositional attitudes that Elephant’s commitments and history-referring constructs presuppose.
Circumscription - A Form of Nonmonotonic Reasoning — McCarthy 1986; the defeasibility substrate for commitment revision.
The Knowledge Level — Newell 1982; Elephant is a programming language whose native level of description is Newell’s knowledge level.
Foundations Of Illocutionary Logic — Searle & Vanderveken, the philosophical spine McCarthy adapts
Speech Act Theory
Agent Communication Languages
KQML
KQML Overview
KQML as an Agent Communication Language
FIPA-ACL
Performatives
Commitment-based Semantics
Agent Communication And Institutional Reality
Agent-Oriented Programming
Intention Is Choice with Commitment
Assigning Meanings to Programs
Hoare Logic
Formal Verification
Verifiable Semantics
Foundations of Logic Programming - Lloyd
Intent Formalization - A Grand Challenge for Reliable Coding
A Scalable Communication Protocol for Networks of LLMs
Institutional Reality

Ascribing Mental Qualities to Machines

Reference: John McCarthy (1979). Stanford CS Department; reprinted in Formalizing Common Sense: Papers by John McCarthy (V. Lifschitz ed., Ablex, 1990). Source file: mccarthy-ascribing.pdf. URL

Summary

McCarthy argues that ascribing beliefs, desires, intentions, knowledge, and other mental qualities to machines (including simple ones like thermostats) is legitimate when the ascription conveys the same information about the machine that it would about a person, and useful when it helps us predict, repair, or improve the machine’s behaviour. He proposes two new definitional tools — definitions relative to an approximate theory, and second-order structural definitions — so that mental-state vocabulary can be applied to physical systems conservatively rather than by reduction to physics.

This is the philosophical foundation for the entire mentalistic (BDI) tradition in agent research that ACL Rethinking Principles pushes back against. Singh cites McCarthy as the origin of the view that agent communication can be specified by ascribing beliefs and intentions; McCarthy himself is already careful to warn that such ascriptions must be conservative and may be merely convenient shorthand for structural facts.

Key Ideas

Ascribing mental qualities is warranted when it expresses information about the machine concisely — not because the machine “really” has a mind.
Ascription is most useful precisely when the structure of the system is incompletely known; for fully-listed programs one could in principle simulate instead.
Mental qualities should be ascribed separately (belief without desire, desire without consciousness, etc.) rather than bundled into a monolithic concept of mind; different machines warrant different subsets.
Novel definitional tools: (1) definitions relative to an approximate theory — a mental predicate is defined only within a coarser theory that abstracts away from physical detail; (2) second-order structural definitions — mental qualities defined by the existence of certain structural roles in the system.
Epistemological vs metaphysical adequacy of representations: AI needs representations that capture what is knowable about a situation, not just what is ultimately true.
The approach is intended as conservative (liberal in what it admits having some mental qualities, strict in how each is attributed).

Connections

Conceptual Contribution

Claim: It is legitimate and often necessary to ascribe mental qualities (belief, desire, intention, knowledge) to machines, provided the ascription is conservative, quality-by-quality, and grounded either in an approximate theory that abstracts away from physical detail or in a second-order structural definition that names the role the quality plays.
Mechanism: Philosophical / definitional. Distinguishes epistemological from metaphysical adequacy of representations, separates mental qualities rather than bundling them, and introduces approximate-theory and structural-definition techniques for defining predicates like believes(M, P) over machines.
Concepts introduced/used: Intentional Stance, Mentalistic Semantics, Approximate Theory, Structural Definitions, Epistemological Adequacy, Common Sense Reasoning
Stance: foundational / philosophical
Relates to: Source of the mental-ascription tradition that Intention Is Choice with Commitment formalises and that Semantics and Conversations for an ACL applies to KQML. ACL Rethinking Principles argues this tradition overreaches when used as a compliance criterion for ACLs; McCarthy’s own hedges about conservativism actually support that pushback.

Tags

Behaviour-Based Robotics

The research programme inaugurated by Brooks’s subsumption architecture (1986) and Intelligence Without Representation (1991): build robotic intelligence by composing concurrent behavioural competencies (each a complete sense-act loop) rather than by decomposing into functional modules (perception / world-model / planning / control). Rejects central symbolic representation in favour of letting “the world be its own best model.” Influenced multi-agent systems through the Reactive vs Deliberative Agents dichotomy.

In this vault

Subsumption Architecture

Brooks’s layered reactive architecture in which behavioural modules are stacked so that higher layers subsume (override) lower ones; a canonical weak-agency alternative to symbolic deliberative architectures.

In this vault

A Robust Layered Control System

A Robust Layered Control System for a Mobile Robot

Reference: Brooks, R. A. (1986). A Robust Layered Control System for a Mobile Robot. IEEE Journal of Robotics and Automation, 2(1), pp. 14–23. (Originally MIT AI Lab Memo 864, September 1985.) IEEE DOI · Open access PDF (MIT AI Memo 864)

Summary

Brooks introduces the subsumption architecture — a radical alternative to the sense-plan-act paradigm that dominated robotics through the 1980s. Where the prevailing approach decomposed robot control into functional modules (perception, world modelling, planning, motor control) operating on a single shared symbolic representation, Brooks’s architecture decomposes by behaviour: each layer of the system is a complete sense-act loop implementing one behavioural competence (avoid obstacles, wander, explore, build maps, identify objects, plan, …). Layers run concurrently and are connected by suppression and inhibition wires that allow higher (later-built) layers to subsume the outputs of lower layers. The lowest layer alone produces a useful (if minimal) robot — an obstacle-avoiding wanderer; each additional layer adds more sophisticated competence on top of an already-functional system. There is no central representation, no shared world model, no symbolic planner driving low-level action. Brooks demonstrated the architecture on a real mobile robot (Allen, the AI Lab’s first subsumption-architecture robot) navigating a cluttered office environment in real time — performance unattainable by the symbolic-AI robots of the era. The 1986 paper is the formal architecture description; the underlying philosophical thesis — that intelligent behaviour does not require explicit representation, that the world is its own best model — is developed in the 1991 follow-ups Intelligence Without Representation and Elephants Don’t Play Chess. The subsumption architecture inaugurated behaviour-based robotics as a research programme, influenced multi-agent systems through the reactive vs deliberative agents distinction, and supplied a substantial counter-tradition to BDI-style symbolic agency.

Key Ideas

Decomposition by behaviour, not function: each layer is a complete sense-act loop implementing one behavioural competence; functional decomposition (perception / planning / control) is rejected as the wrong organising principle.
Layered competence: layer 0 is a working (minimal) robot; each subsequent layer adds capability on top of an already-running system. The N-layer system always behaves at least as well as the (N-1)-layer system.
Suppression and inhibition wires: inter-layer communication is by suppression (a higher layer’s output replaces a lower layer’s signal at the suppression node for a fixed time) and inhibition (a higher layer’s signal blocks a lower layer’s output without substituting). No higher-bandwidth representation passes between layers.
No central representation: there is no shared world model. Each layer maintains its own state as needed; cross-layer communication is restricted to the suppression/inhibition primitive.
The world is its own best model: rather than maintain symbolic representations of the world, the robot perceives the world directly when it needs to act on it. Eliminates the symbol-grounding problem and the cost of keeping a world model synchronised with reality.
Real-time, real-environment demonstration: the architecture was demonstrated on Allen, then Herbert, then later the Cog humanoid project — operating in real environments in real time, with performance that the dominant symbolic-AI robotics could not match.
Modular evolution-friendly architecture: layers can be added or removed without modifying others; the architecture is robust to layer failure (the next-lower layer continues to operate). Brooks frames this as an evolutionary architecture in which more sophisticated competences accrete on top of basic survival competences.

Connections

Conceptual Contribution

Claim: Intelligent robot behaviour can be built by decomposing along behavioural competence rather than functional modules: each layer is a complete sense-act loop, layers run concurrently, higher layers subsume lower ones via suppression/inhibition, and there is no central symbolic representation. The architecture is incremental, evolution-friendly, and demonstrably outperforms symbolic-AI robotics in real-time real-world tasks.
Mechanism: Concurrent finite-state-machine layers each implementing one behavioural competence; suppression nodes (replace) and inhibition nodes (block) for inter-layer interaction; no shared world model; demonstration on real mobile robots (Allen, Herbert) in real environments.
Concepts introduced/used: Subsumption Architecture, Behaviour-Based Robotics, Reactive vs Deliberative Agents (the dichotomy this paper inaugurated), Suppression / Inhibition Networks, Layered Competence, Embodiment.
Stance: systems-engineering paper / programmatic break with symbolic-AI orthodoxy.
Relates to: Inaugurates the reactive (or behaviour-based) tradition in agent architectures, opposed at the time to the deliberative / symbolic tradition that produced BDI agents (Rao & Georgeff 1991, Cohen & Levesque 1990) and Agent-Oriented Programming (Shoham 1993). The dichotomy is now mostly resolved as a layered hybrid (3T architecture, BDI with reactive lower layers), but the historical break drove the conceptual repertoire of MAS for two decades. Conceptually adjacent to The Society of Mind (Minsky 1986) — both treat intelligence as the cooperation of many simple specialised agents, though Minsky’s society of agents are still symbolic where Brooks’s subsumption layers are not. The 1991 follow-ups Intelligence Without Representation (already in vault as Intelligence Without Representation) and Elephants Don’t Play Chess extend the philosophical critique. In modern multi-agent systems, the reactive vs deliberative distinction underwrites the design of LLM-agent architectures: the contemporary debate over chain-of-thought / planner-decoupling / tool-use vs end-to-end-trained reactive agents recapitulates Brooks’s polemic with new vocabulary.

Tags

#robotics #subsumption-architecture #brooks #behaviour-based #reactive-agents #foundations

Rice's Theorem

Rice’s Theorem

A foundational result in computability theory (Henry Gordon Rice, 1951–53): every non-trivial semantic property of the partial function computed by a program is undecidable. Source paper: Classes of Recursively Enumerable Sets and Their Decision Problems. “Non-trivial” means the property holds for some computable functions but not others; “semantic” means it depends on the input/output behaviour, not on the syntactic form of the program.

Put differently: you cannot in general decide, by inspecting a program, whether it belongs to any interesting class defined by what it does. Halting is one such property (Halting Problem), but so is “produces output X on input Y,” “terminates for all inputs,” “implements function f,” “contains no unreachable states,” and so on.

Rice’s theorem is the formal frontier against which static-analysis, verification, and capability-bounding claims must be measured. Any tool promising to decide a non-trivial semantic property on arbitrary programs is — by Rice — either restricting the program class (e.g. Finite-state Grammars, typed or total subsets) or approximating (sound-but-incomplete analyses). Whole research programs — LangSec, Formal Verification, Static Analysis, Weird Machine — are organised around this constraint.

Concrete implication cited in House on Rock - LangSec in Ethereum Classic: Ethereum’s gas mechanism cannot “sidestep Turing completeness” to deliver a safety guarantee, because safety is a semantic property and Rice’s theorem makes semantic properties of arbitrary programs undecidable. Gas is a resource bound (non-semantic, decidable) masquerading as a safety property (semantic, undecidable).

Connections

Computability lineage

graph TD
  G["Gödel (1931)<br/>Incompleteness (Principia)"] --> GR["Gödel (1934)<br/>General Recursive Functions"]
  C["Church (1936)<br/>An Unsolvable Problem of Elementary Number Theory"] --> K["Kleene (1936)<br/>On Notation for Ordinal Numbers"]
  GR --> K
  T["Turing (1936)<br/>On Computable Numbers"] --> HALT[[Halting Problem]]
  C --> HALT
  K --> RE["Kleene (1943)<br/>Recursive Predicates and Quantifiers"]
  RE --> POST1["Post (1944)<br/>Recursively Enumerable Sets"]
  POST1 --> POSTPROB["Post's Problem"]
  RE --> MYH["Myhill (1952)<br/>On Definable Sets of Positive Integers"]
  POST1 --> RICE["Rice (1953)<br/>Classes of R.E. Sets and Their Decision Problems"]
  HALT --> RICE
  RICE --> RT((Rice's Theorem))
  RT --> LS[[LangSec]]
  RT --> FV[[Formal Verification]]
  RT --> SA[[Static Analysis]]
  GR -.equivalence.- T
  C -.equivalence.- T

Papers: Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I · General Recursive Functions of Natural Numbers · An Unsolvable Problem of Elementary Number Theory · On Notation for Ordinal Numbers · Recursive Predicates and Quantifiers · Recursively Enumerable Sets of Positive Integers and Their Decision Problems · On Definable Sets of Positive Integers · Classes of Recursively Enumerable Sets and Their Decision Problems · Extensions of Some Theorems of Gödel and Church

Tags

#computability #undecidability #foundational #langsec #verification

Classes of Recursively Enumerable Sets and Their Decision Problems

Reference: Rice, H. G. (1953). Classes of recursively enumerable sets and their decision problems. Transactions of the American Mathematical Society, 74(2), 358–366. DOI 10.2307/1990888. Based on Rice’s 1951 Princeton PhD thesis under Alonzo Church.

Summary

A nine-page paper that established one of the most consequential results in computability theory — now universally known as Rice’s Theorem. Rice’s question: given a class C of recursively enumerable (r.e.) sets, is there an effective procedure that, applied to a Gödel number (index) of an r.e. set W, decides whether W ∈ C? The paper’s central result is that the answer is no whenever C is a non-trivial extensional property — i.e. whenever C is neither empty nor the whole collection of r.e. sets, and membership in C depends only on which set is described, not on how it is described. Every property of the computed function itself (as opposed to syntactic properties of the program text) is therefore undecidable.

The proof is a reduction from the halting problem (Turing’s K). Rice constructs, for an arbitrary index i, a machine whose r.e. set is either a fixed element of C or a fixed element of its complement depending on whether φ_i(i) halts; a decision procedure for C would then decide K, which is known impossible. The technique — parametric construction of “switch” machines that toggle semantic behaviour based on a halting oracle — is the template used throughout undecidability theory for subsequent results (Rogers’ isomorphism theorem, the Myhill isomorphism, the theory of m-reducibility).

Beyond the headline theorem, the paper classifies decision problems about r.e. sets by the logical complexity of the class C: some non-trivial classes are Σ₁-hard, others Π₁-hard, others fall at higher levels of the arithmetical hierarchy. This classification anticipates the later development of degree theory. The paper is short, elementary, and entirely foundational: it tells us, once and for all, that semantic questions about arbitrary programs cannot be answered by mechanical inspection. Every program-analysis, verification, and capability-bounding enterprise since has been organised around the frontier Rice drew — by restricting the class of programs considered, approximating (sound-but-incomplete), or proving properties syntactically rather than semantically.

Key Ideas

Theorem B (Rice’s Theorem): for any non-trivial class C of r.e. sets, the problem of deciding whether a given r.e. set belongs to C is undecidable.
Extensional vs. intensional properties: C must depend on what is computed (the set), not on how (the index/program text). Intensional properties (program size, presence of a given opcode) can be decidable.
Proof by reduction from the halting problem, via a parametric “switch” construction that conditionally produces an element of C or its complement depending on whether a reference computation halts.
Arithmetical hierarchy classification of classes of r.e. sets by the quantifier complexity of their defining predicates, foreshadowing Kleene’s and Rogers’ later work.
Implicit corollary: every tool that claims to decide a non-trivial semantic property of arbitrary programs must either (i) restrict the input class, (ii) approximate, or (iii) violate computability.

Connections

Conceptual Contribution

Claim: There is no uniform effective procedure that decides any non-trivial extensional property of recursively enumerable sets; equivalently, every non-trivial semantic property of the partial function computed by an arbitrary program is undecidable.
Mechanism: Given a hypothesised decision procedure for a non-trivial class C, and a distinguishing pair A ∈ C, B ∉ C, construct for each index i a machine M_i that simulates φ_i(i) and, if it halts, begins enumerating A; otherwise enumerates B. The set enumerated by M_i is in C iff φ_i(i) halts, so a decision procedure for C would decide the halting problem — contradiction.
Concepts introduced/used: Rice’s Theorem, Halting Problem, Computability, Recursive Function, Universal Turing Machine
Stance: foundational theorem paper (computability theory)
Relates to: Generalises Turing’s halting theorem from the specific property “halts on input x” to all non-trivial semantic properties; sets the decidability frontier that all subsequent work in Formal Verification, Static Analysis, and LangSec (Security Applications Of Formal Language Theory, The Halting Problems of Network Stack Insecurity) must respect; directly underwrites the Rice’s-theorem argument in House on Rock - LangSec in Ethereum Classic that Ethereum’s gas mechanism cannot deliver a semantic safety guarantee.

Shannon Entropy

The expected self-information of a random variable, H(X) = -Σ p(x) log p(x), measuring its average uncertainty in bits. It bounds the best achievable lossless compression and, via its relationship to Kolmogorov complexity, links statistical and algorithmic notions of information.

In this vault

Channel Capacity

Shannon’s C = max_{p(x)} I(X;Y) — the supremum of mutual information achievable over a memoryless channel with input distribution p(x). The noisy-channel coding theorem (A Mathematical Theory of Communication) establishes its operational meaning: any rate R < C is achievable with arbitrarily low error probability via sufficiently long block codes; any rate R > C is not. For the additive-white-Gaussian-noise channel of bandwidth B and signal-to-noise ratio S/N, C = B log₂(1 + S/N). Bounds the throughput of any communication channel — including LLM-mediated agent communication.

In this vault

A Mathematical Theory of Communication

Reference: Shannon, C. E. (1948). A Mathematical Theory of Communication. Bell System Technical Journal, 27(3), pp. 379–423 and 27(4), pp. 623–656. (Republished 1949 with additional commentary by Warren Weaver as The Mathematical Theory of Communication, University of Illinois Press.) DOI · Open access PDF (Harvard) · Internet Archive (BSTJ scan)

Summary

Shannon’s two-part 1948 paper founds information theory as a discipline. The setting is the engineering problem of communication: a source produces messages, an encoder transforms them into signals over a noisy channel, a decoder attempts to reconstruct the original. Shannon’s first move is to argue that the meaning of messages is irrelevant to the engineering problem — only their statistical structure matters. He then develops the foundational notions: entropy H = -Σ p_i log p_i as the average information content per symbol of a source; mutual information I(X;Y) = H(X) - H(X|Y) as the information one variable carries about another; channel capacity C = max I(X;Y) as the supremum of mutual information over all input distributions. The technical heart consists of two coding theorems. Source coding (noiseless coding): any source with entropy H can be losslessly compressed at rate arbitrarily close to H bits per symbol, but no lower. Channel coding (noisy-channel coding): any source with entropy below the channel capacity C can be transmitted with arbitrarily low error probability using sufficient block length, but transmission above C necessarily incurs error. Together these establish the operational meanings of entropy and capacity and bound what any communication system can achieve. The companion Mathematical Theory of Communication (1949) adds Weaver’s expository introduction, popularising the framework and inaugurating the broader engagement of philosophy and the social sciences with information theory. Shannon’s framework supplies the technical foundation for every communication system, the conceptual foundation for algorithmic information theory and the MDL principle, and a recurring background reference in agent-communication design — most explicitly in Why AI Agents Communicate In Human Language, which frames the case against natural-language inter-agent communication in Shannon-theoretic terms (lossy channel, low capacity per token, ambiguous code).

Key Ideas

Engineering decoupling from meaning: the engineering problem of communication is independent of semantic content; only the statistical structure of the source matters.
Entropy as average information: H(X) = -Σ p_i log_2 p_i measures the average uncertainty of a random variable in bits; for an i.i.d. source emitting symbols with probabilities p_i, H is the lower bound on bits-per-symbol for lossless compression.
Mutual information: I(X;Y) = H(X) - H(X|Y) = H(Y) - H(Y|X) symmetrically measures how much knowing Y reduces uncertainty about X (and vice versa).
Channel capacity: C = max_{p(x)} I(X;Y) — the maximum mutual information achievable over a memoryless channel with input distribution p(x). Capacity is the operational supremum on reliable transmission rate.
Source coding theorem: lossless compression can achieve rate arbitrarily close to H (entropy) but no lower; the practical realisation is via Huffman coding, arithmetic coding, and variants.
Noisy channel coding theorem: for any rate R < C, there exists a coding scheme achieving error probability arbitrarily close to zero with sufficient block length; for R > C, error probability is bounded away from zero. The result is non-constructive — Shannon’s proof uses random coding — but the existence guarantee is what made coding theory a field.
Continuous channels and AWGN capacity: the second part extends the discrete results to continuous channels, deriving the famous C = B log(1 + S/N) for additive-white-Gaussian-noise channels of bandwidth B and signal-to-noise ratio S/N.
Ergodic processes and Markov sources: Shannon’s analysis carefully extends from i.i.d. to ergodic and Markov sources, motivating the asymptotic equipartition property (AEP) and laying the groundwork for source coding of non-i.i.d. data.

Connections

Conceptual Contribution

Claim: The engineering problem of communication is mathematically separable from semantics; the right primitives are entropy (uncertainty per symbol of a source), mutual information (information one variable carries about another), and channel capacity (supremum of reliable transmission rate over a noisy channel). Two coding theorems establish the operational meaning of these quantities — entropy as the lossless-compression lower bound, capacity as the reliable-transmission upper bound.
Mechanism: Probabilistic model of source / channel / receiver; definition of entropy, conditional entropy, joint entropy, and mutual information; noiseless source-coding theorem (lossless compression to within ε of H); noisy channel-coding theorem (reliable transmission below C, error-bounded above C); extension to continuous channels and Gaussian noise.
Concepts introduced/used: Shannon Entropy, Shannon Information, Mutual Information, Channel Capacity, Source Coding Theorem, Noisy-Channel Coding Theorem, Asymptotic Equipartition Property.
Stance: founding paper of an entire discipline.
Relates to: Direct technical predecessor of Kolmogorov complexity / Algorithmic Information Theory (Solomonoff, Kolmogorov, Chaitin 1960s) — where Shannon measures the average information of an ensemble, AIT measures the absolute information of an individual object as the length of its shortest description; both are operationally founded on the same coding-theorem intuition. Shannon’s deliberate decoupling of the engineering problem from semantics inaugurates the running tension in agent communication between Shannon information (statistical, channel-bounded) and meaningful information (semantic, conventional, illocutionary). The agent-communication-language tradition exists precisely to address what Shannon’s framework deliberately set aside; nevertheless, the engineering bounds Shannon establishes constrain any agent communication channel, including LLM-mediated natural-language exchange. Why AI Agents Communicate In Human Language makes this explicit: natural language as inter-agent code has low channel capacity per token, high error probability under lossy LLM compression, and ambiguous decoding — Shannon-theoretic objections that motivate the case for structured ACLs. Conceptually adjacent to Chomsky 1956, which addresses the generative-grammatical structure of language as a parallel layer to Shannon’s statistical structure; together they delimit the design space of any communication system.

Tags

#information-theory #shannon #entropy #channel-capacity #foundations #communication

Three Models for the Description of Language

Reference: Noam Chomsky (1956). IRE Transactions on Information Theory. Source files: 195609-.pdf, chomksy.txt. URL

Summary

Chomsky’s seminal paper comparing three candidate models of linguistic structure — finite-state Markov processes, phrase-structure grammars, and transformational grammars — and showing that each is strictly more powerful than the last. He proves that English cannot be described by any finite-state grammar (via dependencies like “either…or”, “if…then” that require unbounded memory), and argues that even phrase-structure grammars, while formally adequate, yield awkward and complex descriptions of phenomena (auxiliaries, passives, discontinuous elements) that transformational rules handle elegantly.

The paper founded generative linguistics and the Chomsky hierarchy, and established transformational grammar as the preferred formalism for natural-language syntax.

Key Ideas

Finite-state grammars cannot generate English (mirror-image / nested dependencies)
Phrase-structure grammars more powerful but still inadequate for transformations
Transformational grammar operates on phrase markers, not strings
Distinction between grammar as discovery procedure vs. evaluation procedure
Foundations of the Chomsky hierarchy

Connections

Conceptual Contribution

Claim: Natural language (English) is not finitely describable by a finite-state Markov process, nor adequately by a pure phrase-structure grammar; a transformational grammar built on top of phrase structure is materially simpler and exposes genuine linguistic insight.
Mechanism: Three candidate models examined formally — (1) finite-state Markov processes, shown incapable of generating mirror-image / nested-dependency constructions central to English; (2) phrase-structure (context-free) grammars, adequate in principle but producing unwieldy, redundant grammars; (3) transformational grammars, where a kernel of simple sentences plus transformations derives the rest, yielding compact and explanatorily powerful descriptions.
Concepts introduced/used: Finite-state Grammars, Phrase-structure Grammar, Context-Free Grammars, Transformational Grammar, Chomsky Hierarchy, Generative Grammar, Kernel Sentences, Markov Processes, Compositionality
Stance: formal / linguistic-theory
Relates to: Foundational reference point for any discussion of language structure, including emergent-language work (Emergence of Grounded Compositional Language in Multi-Agent Populations, Multi-Agent Cooperation and the Emergence of Natural Language) where “compositionality” is the property Chomsky’s phrase-structure was designed to capture. Complements Algorithmic Information Theory - Grunwald Vitanyi’s description-length view with a structural/syntactic one. Distant ancestor of the parser-design rigour demanded by PKI Layer Cake - Kaminsky Patterson Sassaman.

Tags

Operational Transformation

Ellis & Gibbs’s (1989) concurrency-control technique for real-time collaborative editing: each replica executes local operations optimistically, and remote operations arriving over the network are transformed by the operations executed locally since the common ancestor before being applied. The transformation preserves the user’s intended effect under concurrent modification. The technical substrate of Google Docs, Office Online, Etherpad. Conceptual ancestor of CRDTs, which achieve the same convergence guarantees through commutative operations rather than transformation functions.

In this vault

Concurrency Control in Groupware Systems

Reference: Ellis, C. A. & Gibbs, S. J. (1989). Concurrency Control in Groupware Systems. In Proceedings of the 1989 ACM SIGMOD International Conference on Management of Data, pp. 399–407. (Foundational follow-ups: Ressel, Nitsche-Ruhland & Gunzenhäuser 1996 An Integrating, Transformation-Oriented Approach to Concurrency Control and Undo in Group Editors (CSCW ’96, the adOPTed algorithm); Sun, Jia, Zhang, Yang & Chen 1998 Achieving Convergence, Causality Preservation, and Intention Preservation in Real-Time Cooperative Editing Systems (TOCHI 1998, the CCI model).) ACM DOI · Open access PDF (LRI)

Summary

Ellis and Gibbs introduce Operational Transformation (OT), the foundational concurrency-control technique for real-time collaborative editing. The setting is a groupware system in which multiple users edit a shared document concurrently, with each user’s local replica updated optimistically (no locking, no waiting for a server) and remote operations applied as they arrive over the network. The naive approach — apply each remote operation as-is — fails because operations from different sites may have been generated concurrently against different document states, and the same operation produces different results depending on what other operations have already executed. OT solves this by transforming each remote operation against the operations that have executed locally since their last common ancestor, so that the transformed operation produces the intended effect when applied to the local state. The fundamental object is the transformation function T(o₁, o₂) returning the version of o₁ that should execute against a state where o₂ has already executed. The properties required of T are summarised in the CCI model (Sun, Jia et al. 1998): convergence (all replicas converge to the same final state when all operations have executed), causality preservation (operations causally related execute in the right order at every replica), and intention preservation (each operation produces the user’s intended effect even when concurrent operations have changed the document around it). The Ellis-Gibbs paper supplied the foundational dOPT algorithm; subsequent decades of work (adOPTed, GOT, GOTO, SOCT2/SOCT3/SOCT4, COT, TIBOT) refined the theory and addressed correctness bugs in the original. OT is the technical substrate of Google Docs, Microsoft Office Online, Etherpad, and many other production collaborative editors. CRDTs (Shapiro et al. 2011) are the conceptual successor that achieves the same convergence guarantees through commutative operations rather than transformation functions.

Key Ideas

Optimistic local execution + transform remote: each user’s operations execute immediately against the local replica; remote operations arriving over the network are transformed by the operations that have executed locally since the common ancestor, then applied.
Transformation function T(o₁, o₂) returns the version of o₁ that achieves the same intended effect when applied to a state where o₂ has already been applied. For text editing, T(insert("X", 5), insert("Y", 3)) returns insert("X", 6) — the position shifts because the prior insertion at position 3 added a character before position 5.
CCI correctness model (Sun, Jia et al. 1998): convergence (all replicas converge to the same state given the same operations in any order), causality preservation (causally related operations execute in causal order everywhere), intention preservation (each operation produces its user’s intended effect even amidst concurrent operations).
Transformation properties: TP1 (T(o₁, o₂) ∘ o₂ = T(o₂, o₁) ∘ o₁ — diamond closure for any pair), TP2 (the analogous property for triples). TP1 alone is sufficient for two-replica systems; TP2 is required for the general case and turns out to be remarkably hard to satisfy correctly — multiple proposed transformation functions have been shown over time to violate TP2 in subtle cases.
History buffers and operation contexts: each replica maintains a buffer of operations executed since the last network synchronisation; remote operations are transformed against the buffer in arrival order, with careful attention to causality.
Server-mediated vs peer-to-peer: the most-deployed OT systems (Google Docs, Apache Wave) use a server-mediated star topology that simplifies the transformation problem; peer-to-peer OT (the academic mainline) requires the full TP1+TP2 machinery.

Connections

Conceptual Contribution

Claim: Real-time collaborative editing of a shared document by multiple concurrent users can be supported by a transformation function that adjusts each remote operation against the operations that have executed locally since the common ancestor — preserving the user’s intended effect even when concurrent operations have changed the document around it. The CCI correctness conditions (convergence + causality preservation + intention preservation) characterise what such a system must achieve.
Mechanism: Optimistic local execution; transformation function T(o₁, o₂) adjusting remote operations against the local operation history; history buffer per replica; transformation properties TP1 (and, in the general case, TP2) ensuring convergence under arbitrary execution orders.
Concepts introduced/used: Operational Transformation, Transformation Function, CCI Model, TP1 / TP2 properties, History Buffer.
Stance: foundational systems-engineering paper.
Relates to: Conceptual ancestor of CRDTs (Shapiro et al. 2011), which achieve the same convergence guarantees through commutative operations on richer data types — eliminating the need for a transformation function at the cost of a more elaborate data-structure design. The two are different solutions to the same problem, with different operational profiles: OT is light on the data structure (any operation type works) but heavy on the protocol (transformation function correctness is subtle); CRDTs are heavy on the data structure (must be carefully designed for commutativity) but light on the protocol (operations are simply broadcast). Production systems mostly use OT (Google Docs, Office Online, Etherpad) or hybrid OT-CRDT designs (Atom Teletype, Yjs in OT-mode); Automerge is the most-prominent pure-CRDT production system. Conceptually adjacent to the CALM Theorem line: OT is a coordination technique for non-monotonic operations on shared state, while CALM characterises the boundary between operations that need coordination and those that don’t. The intention-preservation property of OT is precisely what is missing from the MAST failure modes of multi-agent LLM systems where agents concurrently modify shared state without any equivalent of the OT machinery — a research-and-engineering opportunity that the CRDT literature has begun to address but the LLM-agent-coordination literature has not.

Tags

#operational-transformation #ellis #gibbs #collaborative-editing #concurrency-control #foundations #cci-model

A Comprehensive Study of Convergent and Commutative Replicated Data Types

Reference: Shapiro, M., Preguiça, N., Baquero, C. & Zawirski, M. (2011). INRIA Research Report RR-7506, January 2011. (Subsequently SSS 2011 — Stabilization, Safety, and Security of Distributed Systems, LNCS 6976: 386–400.) Source file: shapiro-crdts-rr7506.pdf. URL

Summary

Shapiro, Preguiça, Baquero and Zawirski give the canonical formal account of Conflict-free Replicated Data Types (CRDTs) — replicated objects whose replicas can be updated concurrently without coordination, and which converge to a deterministic value once all updates have propagated. The paper distinguishes two equivalent specification styles: state-based / Convergent Replicated Data Types (CvRDTs), where each replica’s state forms a join-semilattice and replicas merge by joining states; and operation-based / Commutative Replicated Data Types (CmRDTs), where operations are designed to commute pairwise so that any delivery order yields the same final state under causal broadcast. They prove the two styles equivalent in expressive power and characterise Strong Eventual Consistency (SEC): the stronger sibling of eventual consistency in which all replicas that have received the same set of updates are immediately identical, with no need to wait for the system to “calm down.”

The paper catalogues a library of CRDTs spanning counters (G-Counter, PN-Counter), registers (LWW-Register, MV-Register), sets (G-Set, 2P-Set, OR-Set, LWW-element-Set), maps, sequences, and graphs, together with the design patterns (tombstones, version vectors, causal histories) that make them work. A separate axis treats delta-CRDTs and bandwidth-efficient propagation. The result is the foundational reference for coordination-free replicated state — adopted across Riak, Redis, Soundcloud’s Roshi, Akka, Automerge, and Yjs, and one of the two pillars (alongside the CALM Theorem) of the contemporary “consistency without coordination” programme.

Key Ideas

State-based (CvRDT): replica state is a join-semilattice; updates are monotone state transitions; merge is lattice join. SEC follows automatically from associativity, commutativity, idempotence of join and monotonicity of updates.
Operation-based (CmRDT): replicas exchange operations rather than states; operations must commute pairwise; causal broadcast plus commutativity yields SEC.
Equivalence theorem: every state-based CRDT can be expressed op-based, and vice versa, under appropriate delivery assumptions.
Strong Eventual Consistency (SEC): all replicas that have observed the same updates are byte-identical, regardless of order — strictly stronger than classical eventual consistency.
CRDT zoo: G-Counter, PN-Counter (counters); LWW-Register, MV-Register (registers); G-Set, 2P-Set, OR-Set, Add-Wins/Remove-Wins Sets (sets); OR-Map, RGA, LSEQ (maps and sequences); Add-only Graph (graphs). Each design choice corresponds to a different conflict-resolution policy made explicit.
Tombstones: a standard pattern for monotonising removal — instead of forgetting a removed element, mark it removed (a monotone state change).
Causal-broadcast assumption: op-based CRDTs require the network layer to deliver operations in causal order; state-based CRDTs make weaker assumptions.

Connections

Conceptual Contribution

Claim: Replicated objects can converge deterministically without coordination iff their state forms a join-semilattice with monotone updates (state-based) or their operations pairwise commute under causal delivery (op-based); the two styles are equivalent in expressive power and together yield Strong Eventual Consistency, a precise formal target for replicated data structures that is strictly stronger than classical eventual consistency.
Mechanism: Formalise replica state as a join-semilattice; prove SEC follows from join-associativity / -commutativity / -idempotence plus monotone updates; characterise op-based CRDTs via pairwise operation commutativity under causal broadcast; prove state-based and op-based formulations equivalent. Catalogue counters, registers, sets, maps, and sequences as instances; document tombstones, version vectors, and causal histories as recurring design patterns.
Concepts introduced/used: CRDTs, Strong Eventual Consistency, join-semilattice, Tombstones, Version Vector, Causal Broadcast, Eventual Consistency, CAP Theorem
Stance: foundational / formal-systems
Relates to: Foundational reference for CRDTs across the contemporary distributed-systems stack; the lattice-theoretic substrate that Logic and Lattices for Distributed Programming (Conway et al. 2012) lifts into a programming-language type system, and that Keeping CALM - When Distributed Consistency is Easy (Hellerstein & Alvaro 2019) generalises into the CALM Theorem. Where CALM gives the theorem (monotone ⇔ coordination-free) and BloomL gives a language, this paper gives the data structures: a catalogue of CRDTs that designers can drop into a coordination-free system. The G-Set / OR-Set / version-vector vocabulary is what CBCL - Safe Self-Extending Agent Communication’s SPEC-003 message-store lattice and SPEC-002 causal-protocol layer use directly. Pairs with Time Clocks and the Ordering of Events in a Distributed System (Lamport 1978) on the causal-history side and with Brewers Conjecture and the Feasibility of Consistent Available Partition-Tolerant Web Services on the impossibility-result side: where CAP says you can’t have all three of consistency, availability, and partition-tolerance for arbitrary programs, CRDTs identify a class of programs (those whose state lives in a join-semilattice) for which all three coexist.

Tags

Relational Transducers for Declarative Networking

Reference: Ameloot, T.J., Neven, F. & Van den Bussche, J. (2011). Proceedings of the 30th ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems (PODS ’11), pp. 13–24, Athens. DOI: 10.1145/1989284.1989321. Journal version: Journal of the ACM 60(2):15, 2013, DOI: 10.1145/2450142.2450151. arXiv:1012.2858 [cs.DB]. Source file: ameloot-neven-vandenbussche-pods11.pdf. URL

Summary

Ameloot, Neven and Van den Bussche supply the formal proof of the conjecture that came to be known as the CALM theorem — Consistency As Logical Monotonicity. They propose a precise computation model for “eventually consistent” distributed querying based on relational transducer networks: each node is a relational transducer (a finite-state machine over relations) with input, output, send, receive, and memory relations; a network of such transducers exchanges tuples asynchronously over an unreliable but eventually-delivering channel. Within this model they give formal definitions of three properties that had previously been informal: eventual consistency (every fair run converges to the same output), coordination-freeness (no node ever waits for another node’s input before producing output), and obliviousness (a syntactic restriction on transducer programs that forbids inspection of the network state).

The paper’s main result is a tight characterisation: the queries computable by coordination-free transducer networks are exactly the monotone queries, and the syntactic class of oblivious transducers also captures exactly the monotone queries. Coordination is therefore necessary for non-monotone queries — the negative side of the result — and sufficient for any computable query, since transducer networks that are not coordination-free are Turing-complete. This is the theorem that Keeping CALM - When Distributed Consistency is Easy (Hellerstein & Alvaro 2019) presents in its accessible form, and the formal kernel that lattice-typed languages like BloomL exploit for their static monotonicity guarantees.

Key Ideas

Relational transducer networks: each node a finite-state relational machine with input/output/send/receive/memory relations; communication asynchronous and unordered but eventually-delivering.
Eventual consistency, formally: every fair run converges to the same output; orthogonal to the order in which messages are delivered.
Coordination-freeness, formally: at no point does a node block waiting on input from another node before emitting output for which it has the data.
Obliviousness: a syntactic restriction (transducer rules cannot inspect “network state” predicates) that captures coordination-freeness without referring to runtime behaviour.
Main theorem: the class of queries computable by coordination-free (equivalently, oblivious) transducer networks is exactly the class of monotone queries. Non-monotone queries require coordination.
Power of coordination: transducer networks that are allowed to coordinate are Turing-complete — coordination buys arbitrary computational power, monotonicity buys distribution-friendliness.

Connections

Conceptual Contribution

Claim: A distributed query is computable in a coordination-free, eventually-consistent way if and only if it is monotone — and the syntactic class of oblivious relational transducers captures exactly this monotone fragment, giving a structural rather than runtime characterisation of which programs admit coordination-free distributed implementation.
Mechanism: Formalise distributed querying as a network of relational transducers exchanging tuples over an asynchronous, unordered, eventually-delivering channel; define eventual consistency, coordination-freeness, and obliviousness as crisp properties of runs/programs respectively; prove the biconditional monotone-query ⇔ coordination-free transducer network ⇔ oblivious transducer program via constructions in both directions; show that lifting the coordination-freeness restriction makes transducer networks Turing-complete.
Concepts introduced/used: Relational Transducer, CALM Theorem, Monotonic Logic, Eventual Consistency, Coordination Avoidance, Confluence, Datalog, oblivious transducer
Stance: foundational / theoretical
Relates to: The formal kernel that Keeping CALM - When Distributed Consistency is Easy (Hellerstein & Alvaro 2019) elaborates into the contemporary CALM-theorem narrative — Hellerstein-Alvaro is the manifesto, this is the theorem. Pairs structurally with Verifiable Semantics for ACLs (Wooldridge 1998) in the agent-communication tradition: both are theorems that turn long-running informal claims (Singh’s “social agency is testable”, Hellerstein-Alvaro’s “distributed consistency is easy when monotonic”) into precise decidability/expressivity results. Companion to Logic and Lattices for Distributed Programming (Conway et al. 2012), which gives the language in which monotonicity is statically checkable, and to A Comprehensive Study of Convergent and Commutative Replicated Data Types (Shapiro et al. 2011), which gives the data structures (CRDTs) that natively live in the monotone class. Load-bearing reference for CBCL - Safe Self-Extending Agent Communication’s SPEC-003: causal-protocol verification is monotone, hence (by this theorem) coordination-free across replicas.

Tags

Logic and Lattices for Distributed Programming

Reference: Conway, N., Marczak, W.R., Alvaro, P., Hellerstein, J.M. & Maier, D. (2012). Proceedings of the 3rd ACM Symposium on Cloud Computing (SoCC ’12), Article 1, pp. 1–14. ACM, San Jose, CA. DOI: 10.1145/2391229.2391230. Source file: conway-bloomL-socc12.pdf. URL

Summary

Conway et al. extend Bloom (a Datalog-derived language for distributed programming) with lattice-typed variables — Lattice<T> collections whose merge operation is the join of an explicit join-semilattice — yielding BloomL. The contribution is a clean lifting of the CALM story from set-of-tuples monotonicity to arbitrary lattice monotonicity: a BloomL program whose every operation is a monotone function over its inputs’ lattices is automatically eventually consistent, regardless of message order or duplication. Programmers can build domain-specific lattices (max-counters, min-clocks, version vectors, custom merge functions) and use them in monotone code with the same coordination-free guarantee Bloom provides for sets.

The paper develops the type system that makes this work: lattice morphisms (functions that preserve the join operation) and monotone functions (functions that are non-decreasing with respect to the lattice order) are statically checkable, so a syntactically-monotone BloomL program is provably confluent. A type-and-effect analysis distinguishes monotone code paths (coordination-free) from non-monotone ones (which need external coordination — e.g. quorum, two-phase commit). Case studies replay canonical distributed problems — shopping carts, Bayou-style replication, distributed locking — showing that lattice typing turns the “do I need to coordinate here?” question into a typing question. BloomL is also the substrate for CRDTs thinking inside a programming language: CRDTs become a special case of lattice-typed values plus monotone access patterns.

Key Ideas

Lattice variables in Bloom: a Lattice<T> is a value plus a merge function satisfying join-semilattice axioms (commutativity, associativity, idempotence). Updates apply merge; reads return the current value.
Monotone functions become first-class: lattice morphisms (f(merge(x, y)) = merge(f(x), f(y))) and monotone functions are tagged in the type system; non-monotone access is restricted to designated boundaries.
CALM at the lattice level: monotonic BloomL programs are confluent (eventually consistent without coordination); the analysis is local and compositional.
Built-in lattice library: max, min, set-union, version vectors, lww-register, plus user-defined lattices via a small interface.
Stratified non-monotonicity: where coordination is unavoidable, the language demands an explicit barrier — making the cost visible at the source level.
Foundation for CRDT thinking: every state-based CRDT is a lattice; BloomL gives them a programming-language home where the safety conditions are checked statically.

Connections

Conceptual Contribution

Claim: Lifting Bloom’s set-of-tuples monotonicity story to arbitrary join-semilattices yields a programming model in which monotonicity (and therefore coordination-freeness and eventual consistency) is type-checked statically: lattice variables carry their merge operation, monotone functions are explicit, and any code path that escapes monotonicity must announce it.
Mechanism: Add Lattice<T> types to Bloom with explicit merge operations; classify operations as monotone or non-monotone via a type-and-effect system; require non-monotone access to occur at explicit stratification barriers; support user-defined lattices via a small interface; maintain Bloom’s existing rule semantics so existing tuple-monotonic code is unchanged.
Concepts introduced/used: Bloom Language, join-semilattice, lattice morphism, monotone function, CALM Theorem, CRDTs, Confluence, Coordination Avoidance
Stance: foundational / language design
Relates to: Direct precursor of Keeping CALM - When Distributed Consistency is Easy (Hellerstein & Alvaro 2019), which generalises this lattice-monotonicity argument into a full positive theorem against the negative-result tradition of CAP Theorem and FLP. Companion to Relational Transducers for Declarative Networking (Ameloot et al.) — Ameloot proves the theorem (monotone ⇔ coordination-free), Conway et al. provide the language in which monotonicity is statically checkable. Together with A Comprehensive Study of Convergent and Commutative Replicated Data Types (Shapiro et al.) it constitutes the lattice-theoretic foundation for CRDTs as a programming-language phenomenon. Load-bearing reference for CBCL - Safe Self-Extending Agent Communication’s SPEC-003 verification-lattice layer, where the message store is a G-Set lattice and verification is a lattice homomorphism that joins coordination-free under store union.

Tags

CALM Theorem

Consistency As Logical Monotonicity (Hellerstein 2010 conjecture; Ameloot, Neven, Van den Bussche 2013 proof). A distributed program has a consistent, coordination-free implementation if and only if it is expressible in monotonic logic.

Monotonic programs produce a set of outputs that only grows as inputs arrive (S ⊆ T ⟹ P(S) ⊆ P(T)). Such programs are safe under missing information: any conclusion reached on a subset of inputs remains valid when more arrive. Non-monotonic programs may retract earlier conclusions, so they must wait for “all the news” — which is what distributed coordination enforces.

CALM is the positive counterpart to the CAP Theorem: it names the exact class of programs that can satisfy Consistency, Availability, and Partition-tolerance simultaneously.

Why it matters

Moves consistency from a property of storage (linearizability, serializability) to a property of programs — Confluence.
Tells programmers what kinds of features are free (monotonic: set union, counting up, set-containment) and what must be paid for (non-monotonic: set difference, strict aggregation, count-exact, deletions without tombstones).
Gives a design rule for coordination-free systems: build from monotonic primitives — CRDTs, Immutable Data Structures, Tombstones, monotonic accumulators — and only add coordination at non-monotonic boundaries.

Formal statement

Using Relational Transducer networks as the execution model and Confluence as the consistency criterion, Ameloot et al. prove: a query Q has a coordination-free distributed evaluation plan iff Q is monotone.

In this vault

Keeping CALM - When Distributed Consistency is Easy — the definitive survey
CAP Theorem
Confluence
Monotonic Logic
Coordination Avoidance
Relational Transducer
Bloom Language
Dedalus
CRDTs
Non-monotonic Reasoning

Keeping CALM - When Distributed Consistency is Easy

Keeping CALM: When Distributed Consistency is Easy

Reference: Joseph M. Hellerstein & Peter Alvaro (2019). arXiv:1901.01930v2. Source file: ../1901.01930v2.pdf (in parent directory). URL

Summary

An accessible, updated statement of the CALM Theorem — Consistency As Logical Monotonicity: a program has a consistent, coordination-free distributed implementation if and only if it is monotonic in a formal logical sense. Monotonic programs are “safe” under missing information and can proceed without waiting: once something has been concluded, it stays concluded. Non-monotonic programs (“change their mind” in the face of new inputs) are necessarily order-sensitive and therefore require coordination to produce a single deterministic outcome.

CALM is a positive counterpart to the negative results of the CAP Theorem and the FLP impossibility. Where CAP says “you can’t always have it all”, CALM delineates the class of programs that can in fact satisfy all of C, A, and P simultaneously: exactly the monotonic ones. The theorem shifts attention away from storage consistency (linearizability, serializability) toward program consistency — Confluence: deterministic outcomes despite non-deterministic message delivery and ordering.

The paper traces the theorem’s implications for Bloom Language, Dedalus, CRDTs, coordination-free design patterns (monotonic accumulation, tombstones, immutable data), distributed garbage collection, and Amazon’s shopping-cart example. It closes with open questions: expressiveness of monotonic languages, program synthesis targeting monotonicity, repair of non-monotonic code, and a possible Stochastic CALM for near-optimum stochastic algorithms.

Key Ideas

Monotonicity ⇔ coordination-freeness ⇔ consistency (CALM)
Program consistency = confluence: same outputs regardless of message order / batching
Non-monotonic operations retract earlier conclusions, hence must wait for “all the news” — requiring Coordination Avoidance logic to know when
Formalisation via Relational Transducer networks (Ameloot, Neven, Van den Bussche)
CAP is a special case: linearizable storage is one non-monotonic operation; CALM asks the question across all programs
Practical playbook: immutable data structures, tombstones, set-monotonic accumulation, CRDTs as object-oriented monotonic types
Bloom gives syntactic monotonicity checking — a programmer writing monotonic Bloom is guaranteed coordination-free correctness

Connections

CALM Theorem
CAP Theorem
Confluence
Monotonic Logic
Coordination Avoidance
Bloom Language
Dedalus
CRDTs
Relational Transducer
Non-monotonic Reasoning
Gossip-Based Computation of Aggregate Information
Gossip-based Aggregation in Large Dynamic Networks
Extensible Distributed Coordination
Are Multiagent Systems Resilient to Communication Failures
Foundations of Logic Programming - Lloyd
Logic and Lattices for Distributed Programming — Conway et al. 2012 (BloomL; lattice-typed lifting of CALM)
Relational Transducers for Declarative Networking — Ameloot, Neven & Van den Bussche 2011 (the formal proof of CALM)
A Comprehensive Study of Convergent and Commutative Replicated Data Types — Shapiro et al. 2011 (the CRDT canonical reference)

Conceptual Contribution

Claim: A distributed program is consistent and coordination-free iff it is expressible in monotonic logic — a tight, provable characterisation that converts “distributed consistency is hard” into a precise question about a program’s logical shape.
Mechanism: Formalise programs as networks of Relational Transducers (Ameloot et al.); define Confluence as program-level determinism under non-deterministic delivery; prove biconditional between confluence and monotonic-logic expressibility.
Concepts introduced/used: Monotonic Logic, Confluence, Coordination Avoidance, Relational Transducer, Bloom Language, Dedalus, CRDTs, CAP Theorem, Immutable Data Structures, Tombstones, Stochastic CALM
Stance: foundational / survey
Relates to: Provides the theoretical companion to the Gossip Protocols cluster (Gossip-Based Computation of Aggregate Information, Gossip-based Aggregation in Large Dynamic Networks) — gossip aggregation with mass conservation is exactly a monotonic accumulation, hence coordination-free. Frames why Extensible Distributed Coordination must reach for stored-procedure coordination precisely where programs are non-monotonic. Contrasts with Are Multiagent Systems Resilient to Communication Failures: that paper shows game-theoretic MAS are brittle under message loss — CALM identifies the logical class of programs immune to such loss. The monotonic/non-monotonic split echoes Foundations of Logic Programming - Lloyd’s distinction between Horn-clause logic and Negation as Failure.

Identifiability

In causal inference, a causal query — most commonly an interventional distribution P(Y | do(X = x)) — is identifiable from observational data over a variable set V iff it can be written as an expression in the observational distribution P(V). Identifiability is a graphical property: it depends only on the causal DAG, not on the parametric form of the distribution. Pearl’s Backdoor Criterion and Front-door Criterion give sufficient graphical conditions; Shpitser–Pearl 2006’s ID algorithm is sound and complete for identification — it finds an expression if and only if one exists. The Rubin / potential-outcomes counterpart uses the Ignorability + Positivity conditions to characterise when standardisation by covariates yields the average treatment effect. For CIVeX-style certificates, identifiability is the property the certificate establishes — the prover ships the DAG, assumptions, and ID derivation; the host checks the derivation rather than re-running the algorithm.

In this vault

Causal Inference

The branch of statistics and computer science that develops formal apparatus for reasoning about causes rather than mere associations: when can we conclude from observational or interventional data that X causes Y, that intervening on X would shift Y, or that Y would have been different had X been different? Two complementary traditions: Pearl’s graphical / structural-causal-model framework (DAGs + the do-Calculus + the ID Algorithm) and Rubin’s counterfactual / potential-outcomes framework (ignorability + positivity + propensity-score / IV / matching estimators). Formal mappings between the two are now standard (Pearl–Bareinboim 2009). For CBCL / CIVeX, causal inference is the substrate: CIVeX certificates carry causal DAGs and identifiability proofs, checked rather than re-derived — the causal analogue of PCC.

In this vault

Causal Diagrams for Empirical Research - Pearl — Pearl 1995, the modern graphical framework
Causality - Pearl — Pearl 2000/2009 textbook
Identification of Joint Interventional Distributions - Shpitser Pearl — complete ID algorithm
Potential Outcomes Framework - Rubin — Rubin 1974, the counterfactual framework
do-Calculus
Backdoor Criterion
Front-door Criterion
Structural Causal Model
Counterfactual
Identifiability
Causal DAG
Instrumental Variable
Mediation Analysis
Causal Influence of Communication
Causal Threat Graph
Causal Broadcast
CBCL - Safe Self-Extending Agent Communication

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

Information Markets

Markets in which the good traded is information. They are structurally distinct from goods markets because of the Arrow / buyer’s-inspection paradox: buyers need access to evaluate, sellers need to restrict access to prevent theft. AI agents with evaluate + forget capability and / or TEE-mediated disclosure can serve as trusted intermediaries that resolve the paradox.

In this vault

Algorithmic Collusion

The phenomenon — first demonstrated empirically by Calvano et al. 2020 and now extensively replicated — that simple learning agents (Q-learning, deep RL, LLM-based) converge to tacitly collusive pricing equilibria without explicit communication. A central concern for competition policy and for the systemic risk of agent economies.

In this vault

Prompt Injection

Attack where adversary-controlled text inside an LLM’s input context is interpreted as instructions — classic LangSec parser-differential in a natural-language setting.

In this vault

Agent Security

Security concerns specific to LLM-agent systems: tool attacks, prompt injection, memory poisoning, inter-agent trust failures.

In this vault

Emergent Communication

How communication arises between agents through interaction and learning.

Distributed Security

Security of distributed/agent systems: mobile code, secure messaging, language-based defences.

LLM Agents

Large-language-model-powered agents: natural-language coordination, tool use, multi-agent orchestration.

Surveys & frameworks

Protocols & communication

Failures & threats

Lineage

Edge Intelligence

AI distributed across edge devices — relevant as the deployment substrate for modern agent systems.

Language Workbenches

Tools and theory for designing and composing programming languages.

Self-Adaptive Systems

Systems that monitor and modify their own behaviour: self-organisation, self-expression, self-awareness.

Trust and Reputation

Computational models for assessing trustworthiness of agents.

Gossip Protocols

Epidemic information dissemination and aggregation in distributed systems.

Sources

Ontologies

Shared, formal vocabularies for meaning. Essential for agents to understand each other.

Sources

Multi-Agent Systems

Systems of multiple autonomous agents that interact, coordinate, and sometimes compete.

Foundations

Intelligent Agents Theory and Practice — Wooldridge
Multiagent Systems Sycara
Agent-Oriented Programming — Shoham

Coordination & robustness

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

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

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

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

README

Agent Communications — Paper Vault

A zetl vault of summaries of every paper in this repository.

Conventions

One markdown file per paper. Filenames are slugified titles (e.g. KQML-Overview.md).
Each note contains:
- # Title heading
- Reference (authors, year, venue/source file)
- Summary — 1–3 paragraphs of core ideas
- Key ideas — bullet list
- Connections — [[wikilinks]] to related notes or concept pages
Concept notes (e.g. [[KQML]], [[FIPA-ACL]], [[Gossip Protocols]]) act as hubs.
index is the Map of Content (MOC) grouping every note by theme.

Layout

index — Map of Content, every paper grouped by theme
concept-map — the conceptual tour: the ideas and how they interlock
Per-paper notes contain summary + key ideas + connections + ## Conceptual Contribution (claim / mechanism / concepts / stance / relates-to)
Concept hubs (e.g. KQML, LangSec, Commitment-based Semantics, BDI) act as junctions
Fine-grained technical terms are wikilinked without dedicated pages (“wanted pages”) so that future notes can backfill definitions — expected zetl pattern, not a defect

Commands

zetl list         # list notes
zetl check        # validate links
zetl stats        # graph stats
zetl serve        # browse

concept-map

Conceptual Map

A guided conceptual tour through the vault. Where index lists the papers, this page lists the ideas and shows how they interlock. Every paper note now also carries a ## Conceptual Contribution section (claim / mechanism / concepts / stance / relates-to).

1. The Central Tension: What Does a Message Mean?

Agent communication’s perennial question — whose mental states does a message commit? — runs the length of this vault.

Speech Act Theory (Austin → Searle → Foundations Of Illocutionary Logic) fixes a vocabulary: illocutionary force, direction of fit, sincerity and preparatory conditions. Every ACL after this inherits it.
Mentalistic Semantics — grounding message meaning in the beliefs/intentions of sender and receiver. KQML (KQML Overview, KQML Language And Protocol, KQML as an Agent Communication Language) and FIPA-ACL adopt it.
Commitment-based Semantics / Public Semantics — the counter-move. Singh’s critique (ACL Rethinking Principles, Agent Communication Languages - Rethinking the Principles) argues mentalistic semantics is unverifiable: we cannot inspect another agent’s mind, only its public commitments. Agent Communication And Institutional Reality pushes further: every message is a declaration that alters social commitments; Searle’s “counts-as” is the operative logic.
Verifiable Semantics — Verifiable Semantics for ACLs formalises the critique by requiring grounding in program state so conformance is model-checkable. A Common Ontology Of ACLs offers a reconciliation: role-instanced public attitudes unify the two families.
Conversation Policy / Interaction Protocols — even with messages nailed down, coordination needs conversations. Coordinating Agents Using ACL Conversations (Colored Petri Nets), ACRE Agent Conversation Reasoning Engine (Dooley graphs), and An Interaction-oriented Agent Framework for Open Environments (commitment-based protocols) make the conversation first-class.

Surveys mapping this debate: The State of the Art in Agent Communication Languages, Trends in Agent Communication Language.

2. The Language Stack

Messages compose into languages compose into protocols.

Layer	Concept	Representative papers
Content	KIF, ontology term sets	KQML Overview, Ontolingua Portable Ontology Specifications, Handbook On Ontologies
Message	Performatives / illocutions	KQML, FIPA-ACL, Foundations Of Illocutionary Logic
Conversation	Interaction Protocols	Coordinating Agents Using ACL Conversations, ACRE Agent Conversation Reasoning Engine
Transport	Facilitators, routing	KQML Language And Protocol, Model Context Protocol, Agent-to-Agent Protocol

This same stack — content / message / conversation / transport — reappears in the modern LLM-agent protocol wave: see Survey Of AI Agent Protocols and Survey Of Agent Interoperability Protocols, which place Model Context Protocol (tools), ACP, Agent-to-Agent Protocol, and Agent Network Protocol at progressively higher layers.

3. How Does Shared Language Arise?

A separate tradition asks where meaning comes from rather than what it contains.

Linguistic foundations. Three Models for the Description of Language establishes what structure a shared code must have (Chomsky hierarchy, transformational grammar). Algorithmic Information Theory - Grunwald Vitanyi provides the information-theoretic counterpart: meaning is compressed description.
Language Games. Language Games for Autonomous Robots (Steels) shows grounded lexicons self-assemble through situated interaction — no designer required. The same bootstrap appears decision-theoretically in Towards Automating the Evolution of Linguistic Competence and Toward Automated Evolution of ACLs: rational agents negotiate vocabulary when current language fails.
Emergent Communication. The deep-learning revival: Multi-Agent Cooperation and the Emergence of Natural Language, Emergence of Grounded Compositional Language in Multi-Agent Populations — neural agents in referential/signalling games evolve compositional codes. On the Pitfalls of Measuring Emergent Communication is the sharpest critique: most metrics fail to distinguish real communication from confounds; measure positive signalling and positive listening with causal interventions.
Common Business Communication Language is an analogue in the pre-ML era — an open-ended language negotiable between organisations with graceful partial-understanding fallback.
The LLM inflection point. Why AI Agents Communicate In Human Language argues natural language is exactly the wrong inter-agent medium: lossy, non-differentiable, ambiguous. The thread rejoins the ACL debate a quarter-century later.