Agent Communications Vault

Pages

942

Links

5639

Dead links

Orphans

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)
Three Models for the Description of Language — Chomsky 1956
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
Two Faces of Intention — Bratman 1984
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
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
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)
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
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)
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
Foundations of Logic Programming - Lloyd
Foundations Of Illocutionary Logic — Searle & Vanderveken
Assigning Meanings to Programs — Floyd
Algorithmic Information Theory - Grunwald Vitanyi
How Do Committees Invent — Conway
Seven Turrets Of Babel

Cited Foundations (mined from top papers)

Agent Communication Languages (ACLs)

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

LLM Agents & Modern AI Agents

Emergent Communication & Language Games

Ontologies & Knowledge Representation

Programming Languages & Extensibility

Security & Robust Distributed Systems

Gossip & Peer-to-Peer

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

Agent Communication Languages line 33
README line 19
README line 15
concept-map line 135
concept-map line 3

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 the two dominant semantic traditions for Agent Communication Languages: 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, then show translation schemes from FIPA speech acts and from action/propositional 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 perspective (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-verifiable => 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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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.

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

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

Discussed in

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

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

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