OBJS Technical Note

Comparing Agent Communication Languages

Venu Vasudevan Object Services and Consulting, Inc. July 1998

Introduction

Agent architectures need both representation and communication models. Agent representation models include ontologies that define the domain model/vocabulary etc. of a particular domain of discourse, and content languages that represent the agent's mental model of the world (e.g beliefs, desires, intentions). Given a particular domain of discourse, and a particular community of agents that know and do something in this domain, one needs an agent communication model that models the flow of knowledge and attitudes about such knowledge within the agent community. An ACL (agent communication language) provides language primitives that implement the agent communication model. ACLs are commonly thought of as wrapper languages in that they implement a knowledge-level communication protocol that is unaware of the choice of content language and ontology specification mechanism.

Nearly all the ACLs around derive their language primitives from the linguistic theory of speech acts. Speech act theory categorizes human (or machine) "utterances" into different categories depending on the intent of the speaker (human or agent), the effect on the listener (human or agent), and any other physical manifestations of the act of uttering the utterance. Since speech acts are a human knowledge-level communication protocol, it is felt that they would be effective as an agent communication protocol, esp. since agents might operate on behalf of humans. However, the case has also been made for speech acts as appropriate programming language primitives for next generation programming languages (not just ACLs) [McCart92].

KQML [KQML94] is the ACL resulting from the DARPA KSE (Knowledge Sharing Effort) effort, which also produced KIF as the content language (first-order logic + set theory) and Ontolingua as the ontology specification language. In keeping with the wrapper philosophy of ACLs, KQML is insensitive to whether the content it is communicating about is in KIF/Ontolingua or something else. What follows is a brief description of speech acts, a database bigot's view on KQML, and some elaboration on the motivation behind the KQML-Lite (and/or KQML-Right) [KQML-LITE] effort.

Speech Act Theory: In Brief

Speech act theory is a linguistic analysis of human communication. It is relevant to ACLs in that speech act theory serves as one (but not the only) formal basis for deciding ACL language primitives.There are 4600 speech acts at last count, and I doubt if it is the goal of any ACL to cover them all. What does seem to be true is that any ACL primitive that is a true speech act is easily defensible by the language's defenders. Anything that is not, is up for debate.

Table I: Speech Act Types

Speech Act Category	Intent	Example
representatives	state a proposition (represent a state of affairs)
directives	request or command	"Mr.Sulu, engage"
commissives	promise or threat (commit the speaker to a future course of action)	" I promise to give you ten dollars"
expressives	thanks and apologies (indicate a mental attitude on the part of the speaker)
declarations	things that actually change the state of the world	"I now pronounce you man and wife"
verdicatives	pass judgement	"Microsoft stinks"

Above is the list of Searle's categories of speech acts and their meanings. Speech acts are useful in that one can formally represent their illocutionary (i.e what the speaker intended by something) and perlocutionary (i.e the actual effect of the speech act on the hearer) effects. It is upto the agent theory and the agent infrastructure to ensure that agents in the community are ethical and trustworthy, and therefore the perlocutionary behavior of a speech act on the hearing agent is predictable. All this is not the concern of ACLs, which are merely providing the language primitives.

KQML

Description

The architecture underlying KQML is that of a community of agents, each owning and managing a virtual KB (VKB) that represents its mental model of the world. KQML doesn't care about the content language used to represent the mental model (could be KIF, RDF,SL or some other content language). Its goal is to provide knowledge transportation protocol for blobs of content, in some ontology that the sending agent can point to and the receiving agent can access. Agents then query and manipulate the contents of each others VKBs, using KQML as the communication and transport language. KQML presupposes a white-box (or at least gray-box) model of agent community VKBs, and includes direct edits to an agent's VKB by another agent as part of its language primitives.

The KQML specification defines the syntax (and informally the semantics) for a collection of messages (or performatives to be politically correct from a speech act point of view) that collectively define the language in which agents communicate. There is a core set of reserved performatives, but the set is extensible (e.g COOL[Barb95]) and has been extended for different applications. The table below classifies the core KQML performatives based on the KBMS-level communication function, and whether they apply to communicating agent-pairs or to larger communities of agents. Obviously, the latter implies the former. Performatives in purple were part of the KQML '94 spec but seem to have been eliminated in the KQML'97 proposal.

Table II: Classification of KQML Performatives

Function Class	Member Performatives	Level
Query and Response	ask-if,ask-all,ask-about, ask-one, tell,untell,deny, sorry	agent-pair
Cursor Manipulation and Result Formatting	ready, next, discard, rest stream-all, stream-about, eos	agent-pair
advertise or commit to a capability	advertise, unadvertise	agent community
kb editing	insert,uninsert,delete-one, delete-all, undelete	agent-pair
enactment	achieve, unachieve	agent-pair
error handling	error	agent-pair
communication primitives other than pure asynchronous messages	broadcast, forward, standby, subscribe and monitor (like a kb alerter), pipe, break (make and dismantle a pipe), generator	either
trading	broker-one, broker-all, recommend-one, recommend-all, recruit-one, recruit-all	agent-community
name service	register, unregister, transport-address	agent-community

Critique

It is fairly confusing to have a single specification for pair-wise inter-agent communication and management of agent communities. The CORBA analogy would have been a single document that covered IDL and all of COSS.
Services are not adequately described in terms of their minimum required functionality, optional functionality and interfaces that fulfill the functionality. Even where one assembles the provided KQML operations into a service specification, the set of services and the specification of each service in the set seem incomplete.
The rationale for whether something should be in the ACL, not in the ACL, or assumed by the ACL to be in the content language, is unclear. For example, should the ACL provide cursors, or should it assume that the content language is providing some sort of result set object.
It is unclear why each individual operation has a specialized undo operator, and why some don't have one (e.g no unask)
The choice of communication primitives is seemingly arbitrary (why have standby, but not the equivalent of LISP futures)

FIPA ACL

Description

FIPA ACL is the agent communication language associated with FIPA's open agent architecture. As with KQML, FIPA-ACL maintains orthogonality with the content language and is designed to work with any content language and any ontology specification approach. Beyond the commonality of goals and a similarity in syntax, there are a number of significant differences between FIPA-ACL and KQML.

In FIPA-ACL's semantic model, agents are not allowed to directly manipulate another agent's VKB. Therefore KQML performatives such as insert,uninsert,delete-one, delete-all, undelete are not meaningful.
The ACL limits itself to primitives that are used in communications between agent pairs. The FIPA architecture has an AMS (Agent Management System) specification (roughly equivalent to CORBA COSS) that specifies services that manage agent communities. This eliminates the need for register/unregister, recommend,recruit,broker and (un)advertise primitives in the ACL (to be more precise, these primitives are moved to the AMS).
FIPA-ACL and KQML have philosophical differences in terms of what is done in the wrapper language and what is delegated by the wrapper language to the content language. An agent A could tell an agent B to achieve a goal X in a couple of different ways (where the ACL performatives are in orange and the content language clauses in blue):

from A to B: achieve goal X, - thus agents A asks agent B to achieve goal X (all in the ACL vocabulary)
from A to B: tell (achieve goal X). - here agent A says something to agent B that the ACL does not understand (but the content language interpreter interprets as a request to achieve goal X).

In the former (the KQML way), the wrapper language has a specific achieve performative for achieving goals, as it does not assume the content language necessarily has this capability. In the latter case (the FIPA-ACL way), the achieve performative is pushed into the content language, thus eliminating the need for the same in the ACL. To me, this general question (i.e the dividing line between an ACL and the content language) is still unresolved.

For the same reasons as the last point, FIPA-ACL does not provide primitives for cursor manipulation. The FIPA point of view is that iterator objects are part of the content language.

Below are two tables, one a categorization of operators like the KQML table above, and another a list of equivalent operators in FIPA-ACL and KQML.
Table III: Taxonomy of FIPA Performatives

Function Class	Member Performatives
query and response	query-if, query-ref request, request-when, request-whenever inform, inform-if, inform-ref, confirm,disconfirm
communication primitives other than pure asynchronous messages	cfp, propose, reject-proposal, accept-proposal, subscribe (like a kb alerter)
error handling	failure, not-understood

?	agree, cancel

Table IV: Equivalent Operations in FIPA-ACL and KQML

KQML Performative	Equivalent FIPA Performative
ask-if`	query-if
tell, untell	inform
deny	inform or disconfirm
insert, uninsert	inform, disconfirm
subscribe	subscribe
error	not-understood
sorry	refuse or failure

Critique

delegating certain functions to the content language (as opposed to fattening the ACL with wrapper primitives) seems like a plausible approach. It would be desirable for the FIPA-ACL specification to explicitly state what it needs from the content language that it wraps.
cfp seems to be made out to be the universal coordination primitive. I tend to think that other high-level coordination primitives are needed, and a coherent rule about what coordination primitive is in the core language and what in the extension, is needed.
iiop mandated as the transport protocol? Why iiop only, and why mandate.? What should be mandated is a transport model (e.g reliable and strictly sequenced delivery of messages) not the protocol!

KQML Lite (or Right?)

Description

KQML Lite is an attempt to merge KQML and FIPA ACL. Implicit in this is the idea that merging KQML and FIPA-ACL is better than adopting either one of these in their entirety. A key assumption is made in the merging strategy is that FIPA-ACL and KQML are at different levels of abstraction, and that the notion of an ACL can itself be further subdivided into an outer ACL and an inner ACL. Given that, the KQML-Lite authors propose a merging strategy that uses a subset of FIPA-ACL as the outer ACL and a subset of KQML as the inner one.The authors of KQML-Lite state the 2-layer ACL model as self-evident, and go on to a detailed listing of primitives in the merged language. The notion of such a model is not obvious at all to me, esp. after the FIPA spec has indicated the equivalence between FIPA-ACL and KQML operators, and made an argument for why other operators belong outside the scope of a "well designed" ACL. The KQML-Lite authors need to elaborate and convince readers of the validity of the 2-layer ACL model, and the ACL merging strategy. The KQML-Lite proposal does do a much better job than other KQML specs., of enumerating agent services and their interfaces separately and in detail.

Note: KQML-Lite is an odd name for a merging of FIPA-ACL and KQML (it is actually heavier than both KQML and FIPA-ACL in terms of the number of performatives).

Discussion

As mentioned earlier, FIPA vs KQML brings up some philosophical issues about the line between wrapper languages and content languages that need to be looked at. In fact, should wrapper languages be insensitive to the content they carry and therefore completely unaware of content languages at all?

References

[Barb95] Barbuceanu,M. and Fox,M., "COOL: A Language for Describing Coordination in Multi Agent Systems"
[Fini97] Finin,T., Software Agents for Information Retrieval(tutorial)
[Fini97b] Finin,T., Presentation on Agent Communication at the Dartmouth Agents Workshop
[FIPA97] FIPA Version 1.0 specifications - Agent Management (Part 1 of the spec) and Agent Communication Language (Part 2 of the spec).
[Gens94] Genesereth,M. and Ketchpel,S., "Software Agents"
[KQML97] Finin,T. et al., "KQML as an Agent Communication Language", in Software Agents, J.Bradshaw ed., MIT Press, 1995.
[KQML94] Finin,T., Wiederhold,G. et al., "Specification of the KQML Agent-Communication Language plus example policies and architectures", DARPA KSE External Interfaces Working Group Draft.
[KQML-LITE] KQML Lite Specification Report, Lockheed Martin Report for the ALPS program
[Labr] Labrou, Y. and Finin,T., "A Proposal for a new KQML Specification"
[McCart92] McCarthy, J., "Elephant 2000: A Programming Language Based on Speech Acts", unpublished manuscript (on MacCarthy's home page)
[Shoh92] Shoham,Y., "Agent-Oriented Programming", Artificial Intelligence, 60(1993), 51-92.
[SA] Linguistics web page summarizing speech act theory
[Sear69] Searle,J., Speech Acts: An Essay in the Philosophy of Language, Cambridge University Press, 1969