OBJS Technical Note
Comparing Agent Communication Languages
Object Services and Consulting, Inc.
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
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]
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
||state a proposition (represent a state of affairs)
||request or command
||promise or threat (commit the speaker to a future course of action)
||" I promise to give you ten dollars"
||thanks and apologies (indicate a mental attitude on the part of the
||things that actually change the state of the world
||"I now pronounce you man and wife"
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
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
|Query and Response
||ask-if,ask-all,ask-about, ask-one, tell,untell,deny,
|Cursor Manipulation and Result Formatting
||ready, next, discard, rest stream-all, stream-about,
|advertise or commit to a capability
||insert,uninsert,delete-one, delete-all, undelete
|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
||broker-one, broker-all, recommend-one, recommend-all, recruit-one,
||register, unregister, transport-address
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
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 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.
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.
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):
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.
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).
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.
Table III: Taxonomy of FIPA Performatives
Table IV: Equivalent Operations in FIPA-ACL and KQML
|query and response
request, request-when, request-whenever
inform, inform-if, inform-ref,
|communication primitives other than pure asynchronous messages
||cfp, propose, reject-proposal, accept-proposal, subscribe (like a kb
||Equivalent FIPA Performative
||inform or disconfirm
||refuse or failure
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?)
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
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
[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,
web page summarizing speech act theory
[Sear69] Searle,J., Speech Acts: An Essay in the Philosophy of Language,
Cambridge University Press, 1969