Tim Finin and KQML: Giving Software Agents a Communication Language
KQML gave 1990s software agents a shared message language built around performatives such as ask, tell and achieve, separating communicative intent from the syntax of the knowledge being exchanged.
KQML emerged from the DARPA Knowledge Sharing Effort
In the early 1990s, researchers building distributed knowledge-based systems needed agents created by different groups to exchange information without agreeing on one internal representation. The DARPA Knowledge Sharing Effort created the Knowledge Query and Manipulation Language, or KQML, as a high-level communication layer for that problem. A 1993 draft specification led by Tim Finin and collaborators described KQML as a language for knowledge-based systems to share knowledge at run time.[1] The effort treated interoperability as an architectural concern rather than assuming that every agent would be built with the same planner, database or reasoning engine.
Performatives borrowed from speech-act ideas
The communication act was meant to carry pragmatic meaning. Asking, telling and requesting are different relationships between sender and receiver even when the same proposition appears in the message body.
A KQML message described the intention of a communication
KQML organized messages around performatives such as ask, tell, achieve, subscribe and reply. The performative represented what the sender intended to do with the enclosed content rather than merely naming a transport operation. Finin, Fritzson, McKay and McEntire’s 1994 CIKM paper presented KQML as an agent communication language and emphasized that these message types could support both information exchange and richer interaction patterns.[2] This was an important shift from remote procedure calls: two agents could communicate about beliefs, requests or capabilities even when their internal programs were very different.
A message had an envelope and a payload
This layering let agents exchange the same KQML performative while using different knowledge representation languages, provided they agreed on the content language and ontology named in the message.
Content language and communication language were deliberately separated
KQML messages carried parameters describing sender, receiver, language, ontology and content. The outer KQML layer could therefore state that one agent was asking another about a proposition while the proposition itself was expressed in KIF, Prolog, SQL or another representation. The 1993 specification explicitly separated communication conventions from the content language and ontology.[1] That separation anticipated later middleware designs in which envelopes, schemas and payload formats evolve independently. It also forced researchers to recognize that syntactic exchange is not enough: agents must agree on how to interpret both the performative and the domain vocabulary.
Brokers enabled open agent communities
Facilitators could match needs to capabilities, support subscriptions and route information. That architecture anticipated service discovery and middleware patterns that later appeared in distributed systems.
Facilitators made communication more than direct point-to-point messaging
KQML also supported ideas such as facilitators, brokers and capability advertisements. An agent did not always need to know the final service provider in advance; intermediary agents could help locate another agent able to answer a query or perform an action. The UMBC KQML archive preserves the specifications, APIs and discussions that grew around these architectures.[3] This made communication infrastructure part of the multi-agent system itself. Routing a request by capability or subject could be as important as the message syntax, especially in open systems where agents joined dynamically.
Syntax alone could not guarantee understanding
Researchers discovered that interoperable parsing is easier than interoperable meaning. The semantics of an agent message must specify what assumptions a receiver may safely make about the sender’s intent.
Semantics became the central challenge as implementations multiplied
As KQML spread, different implementations and interpretations exposed ambiguity in the meaning of performatives. Yannis Labrou and Tim Finin proposed a revised specification in 1997 with a more carefully defined set of reserved performatives and intended uses.[4] Their related work on semantics and conversations tried to ground communication acts in speech-act theory and define legal exchanges among messages. This was a difficult problem because two systems can parse the same message yet still disagree about what commitments or mental-state effects the message is supposed to create.
KQML influenced the later FIPA standardization effort
FIPA’s later Agent Communication Language work inherited many of the same concerns and explicitly discussed migration for developers familiar with KQML. FIPA described its ACL as based on communicative acts and standardized interaction protocols such as requests, contract nets and auctions.[5] KQML was therefore not the final universal language, but it helped define the technical agenda that standardization bodies would pursue: message envelopes, performative semantics, content languages, ontologies, naming and conversations among autonomous components.
The language exposed a problem modern agent systems still face
The deepest KQML lesson survives in today’s LLM-agent systems. Giving two agents a text channel does not automatically create reliable cooperation. They still need conventions for requests, delegation, tool results, error reporting, identities and shared terminology. Modern systems often encode those rules in JSON schemas, tool-call protocols or orchestration frameworks rather than in KQML syntax, but the underlying interoperability problem is strikingly similar. KQML’s history shows why agent communication is a protocol-design problem, not simply a prompt-writing problem.
Why KQML belongs in the history of multi-agent systems
KQML belongs in multi-agent history because it made communicative intent an explicit software abstraction. Finin and collaborators asked how autonomous programs could exchange knowledge, request actions and discover services without sharing one implementation. The resulting performative model gave the field a vocabulary for discussing agent communication and forced later researchers to confront semantics, conversations and interoperability.[2][4] Its influence is visible whenever an agent protocol distinguishes what a message is trying to accomplish from the raw content carried inside it.
KQML was also a product of an era in which AI researchers expected many specialized knowledge systems to cooperate rather than one giant model to contain every capability. The language was designed around distributed expertise: one agent might know schedules, another prices, and another how to translate vocabularies. That assumption made communication and mediation central engineering concerns. Contemporary agent architectures built around specialized models and tools have revived the same design pressure under different implementation technologies.
The broader significance of this work is that multi-agent systems require explicit machinery for relationships among decision makers. Communication, coordination, incentives, task structure, learning or governance may dominate depending on the problem. The pioneers in this batch helped turn those relationships into concrete software abstractions that could be implemented, analyzed and compared rather than left as informal assumptions.
Works Cited
- 01
- 02
- 03UMBC AgentWeb — KQML Archive agents.umbc.edu
- 04Labrou and Finin — A Proposal for a New KQML Specification ebiquity.umbc.edu
- 05
CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.
Submit a research lead