A Brief Overview of Agent
Communication in the
Semantic Web Era
-- and Beyond -Tim Finin
University of Maryland, Baltimore County
April 2007
http://ebiquity.umbc.edu/resource/html/id/220/
Overview
• Agent communication languages
• 1990-2000 DARPA knowledge sharing
effort
• 1997-2002 FIPA
• 2000- (Semantic) Web
• 2010- and beyond
• Are we making progress?
Agent Communication
• Agent-to-agent communication is key to realizing
the potential of the agent paradigm, just as the
development of human language was key to the
development of human intelligence and societies.
• Agents use an Agent Communication Language
(ACL) to communication information and
knowledge.
• Genesereth (CACM 1994) defined a software
agent as any system which uses an ACL to
exchange information.
Genesereth, M. R., Ketchpel, S. P.: “Software Agents”, Communications of the
Association for Computing Machinery, July 1994, pp 48-53.
Some ACLs
•Knowledge sharing approach
– KQML, KIF, Ontologies
•FIPA
•Ad hock languages
– e.g., SRI’s OAA
?
e.g., team theories,
joint intentions, …
Intentional
Sharing
e.g., KQML, FIPA,
KIF, Aglets, OWL
Knowledge
Sharing
e.g., CORBA,
RPC, RMI
?? Shared
Experiences &
Strategies ??
Object
Sharing
Shared beliefs, plans, goals,
intentions, policies …
Shared facts, rules, constraints,
procedures and knowledge
Shared objects, procedure calls
and data structures
BDI Agents, Theories and
Architectures
• BDI architectures describe the internal state of
an agent by the mental states of beliefs, goals
and intentions
• BDI theories provide a conceptual model of the
knowledge, goals, and commitments of an agent
• BDI agents have some (implicit or explicit)
representations of the corresponding attitudes
• BDI models are important in defining the
semantics of ACLs
BDI Model and Communication
B + D => I
I => A
B + D => I
I => A
• Communication is a means to (1) reveal to others what our BDI
state is and (2) attempt to effect the BDI state of others.
• Note the recursion: an agent has beliefs about the world, beliefs
about other agents, beliefs about the beliefs of other agents,
beliefs about the beliefs another agent has about it, ...
1990-2000
Knowledge
Sharing Effort
Historical Note:
Knowledge Sharing Effort
• Initiated by DARPA circa 1990 with later support from
NSF, AFOSR, etc.
– Participation by ~100 researchers in academia and industry
• Developing techniques, methodologies and software
tools for knowledge sharing and knowledge reuse.
• Sharing and reuse can occur at design,
implementation or execution time.
• Mostly wound down by ~2000 as funding dried up
and industry failed to adopt the ideas
Knowledge Sharing Effort
• Knowledge sharing requires a communication
• … which requires a common language
• We can divide a language into syntax, semantics, and
pragmatics
• Some existing components that can be used independently or
together:
– KIF - knowledge Interchange Format (syntax)
– Ontolingua - a language for defining
sharable ontologies (semantics)
– KQML - a high-level interaction
language (pragmatics)
Propositional
Propositional
attitudes
Knowledge Interchange Format
• KIF ~ First order logic
withset theory
• An interlingua for encoded
declarative knowledge
– Takes translation among n
systems from O(n2) to O(n)
Sys 3
Know. Base
in
Lang3
Know. Base
in KIF
KIF <-> Lang3 Translator
Library
KIF
KIF <-> Lang1 Translator
Know. Base
in
Lang1
Sys 1
KIF <-> Lang2 Translator
Know. Base
in
Lang2
Sys 2
• Common language for reusable knowledge
–
–
–
–
Implementation independent semantics
Highly expressive - can represent knowledge in typical application KBs.
Translatable - into and out of typical application languages
Human readable - good for publishing reference models and ontologies.
• 2003: KIF superceded by Common Logic (http://cl.tamu.edu/)
– http://en.wikipedia.org/wiki/Common_Logic
• Semantic Web languages RDF and OWL are also alternatives
KIF Syntax and Semantics
• Extended version of first order predicate logic
• Simple list-based linear ASCII syntax, e.g.,
(forall ?x (=> (P ?x) (Q ?x)))
(exisits ?person (mother mary ?person))
(=> (apple ?x) (red ?x))
(<<= (father ?x ?y) (and (child ?x ?y) (male ?x))
(=> (believes john ?p) (believes mary ?p))
(believes john '(material moon stilton))
• Model-theoretic semantics
• KIF includes an axiomatic specification of large
function and relation vocabulary and a vocabulary
for numbers, sets, and lists
Common Semantics
Shared Ontologies and Ontolingua
• Ontology: A common vocabulary and agreed upon
meanings to describe a subject domain.
• Ontolingua is a language for building, publishing,
and sharing ontologies.
– A web-based interface to a browser/editor server.
– Ontologies can be automatically translated into
other content languages, including KIF, LOOM,
Prolog, etc.
– The language includes primitives for combining
ontologies.
Common Pragmatics
Knowledge Query and Manipulation Language
• KQML is a high-level, message-oriented, communication
language and protocol for information exchange
independent of content syntax and ontology.
• KQML is also independent of
– transport mechanism, e.g., tcp/ip, email, corba, IIOP,
http ...
– High level protocols, e.g., Contract Net, Auctions, …
• Each KQML message represents a single speech act
(e.g., ask, tell, achieve, …) with an associated semantics
and protocol.
• KQML includes primitive message types of particular
interest to building interesting agent architectures (e.g.,
for mediators, sharing intentions, etc.)
Common High-level Protocols
• There is also a need for communication agents to agree on
the agent-level protocols they will use.
• The protocol is often conveyed via an extra parameter on a
message
– (ask :from Alice :to Bob … :protocol auction42 …)
• Common protocols:
– Contract net
– Various auction protocols
– Name registration
• These protocols are often defined in terms of constraints on
possible conversations and can be expressed as
–
–
–
–
–
Grammars (e.g., DFAs, ATNs, DCGs…)
Petri networks
UML-like interaction (activity) diagrams
Conversation plans
Rules or axioms
Common Service Infrastructure
• Many agent systems assume a common set of
services such as:
–
–
–
–
Agent Name Sever
Broker or Facilitator
Communication visualizer
Certificate server
• These are often tied rather closely to an ACL since
a given service is implemented to speak a single
ACL
• Moreover, some of the services (e.g., name
registration) may be logically ACL-dependent
– e.g., Some ACLs don’t have a notion of an agent’s name
and others have elaborate systems of naming
A KQML Message
performative
parameter
value
(tell :sender
bhkAgent
:receiver
fininBot
:in-reply-to id7.24.97.45391
:ontology
ecbk12
:language Prolog
:content “price(ISBN3429459,24.95)”)
Represents a single speech act or performative
ask, tell, reply, subscribe, achieve, monitor, ...
with an associated semantics and protocol
tell( i,j, Bi ) = fp[Bi Bi   Bi( Bifj Bi  Uifj Bi )]  re[Bj Bi] ...
and a list of attribute/value pairs
:content, :language, :from, :in-reply-to
Performatives (1997)
Insert
Uninsert
Delete-one
Delete-all DB
Undelete
Ask-if
Ask-one
Ask-all
Tell
Untell
Inform
Basic
Inform
Network
Basic
StreamStream
Eos
Query
StandbyCursor
Ready
Next
Reply
Rest
Stream
Discard
Eos
Broadcast
Forward
Request
KQML
Performatives
Goal
Facilitation
Promise
Meta
Achieve
Unachieve
Advertise
Deny
Unadvertise
Subscribe
Broker-one
Recommend-one
Recruit-one
Broker-all
Recommend-all
Recruit-all
Simple Query Performatives
ask-if(P)
ask-one(P)
Sorry
tell(P)
A
tell((p1 p2 p3...))
B
A
B
tell(P1)
tell(P2)
tell(P3)
ask-all(P)
eos
Stream-all(P)
• The ask-one, ask-all, ask-if, and stream-all
performatives provide a basic query mechanism.
Capability Description
advertise(q3)
advertise(q2)
advertise(q1)
ask-all(advertise(P)
A
C
FAC
B
advertise(p1)
advertise(p2)
The advertise performative is used to describe the
performatives an agent is prepared to accept.
Facilitation Performatives
The three facilitation
performatives come in a X-one
and X-all versions:
•Broker-one and broker-all
B
A
Broker
•Recruit-one and recruit-all
advertise(ask(P))
broker(ask(P))
ask(P)
C
tell(P)
tell(P)
•recommend-one and recommend-all
advertise(ask(P))
recruit(ask(P))
A
B
ask(P)
C
recommend(ask(P))
A
adv(ask(P))
B
fwd(adv(ask(P)))
tell(P)
Recruit
Recommendtell(P)
C
ask(P)
Ontology languages vary in expressivity
Catalog/ID
Thesauri
“narrower
term”
relation
DB Schema
Formal
is-a
Frames
(properties)
UMLS
RDF
Wordnet
OO
Terms/
glossary
Simple
Taxonomies
Informal
is-a
Formal
instance
RDFS
Inverse,
Disjointness,
part of…
CYC
DAML
OWL IEEE SUO
Value
Restriction
General
Logical
constraints
Expressive
Ontologies
After Deborah L. McGuinness (Stanford)
Conceptual Schemas
A conceptual schema specifies the intended meaning of
concepts used in a data base
Data
Base:
Data Base
Schema:
Conceptual
Schema:
139
140
…
74.50
77.60
…
Table: price
*stockNo: integer; cost: float
Auto
Product
Ontology
price(x, y) =>
Product
 (x’, y’) [auto_part(x’)
Ontology
& part_no(x’) = x
& retail_price(x’, y’, Value-Inc)
& magnitude(y’, US_dollars) = y]
Units &
Measures
Ontology
1997-2003
Standardization
FIPA
What is FIPA
• http://fipa.org/
• The Foundation for Intelligent Physical Agents
founded as a non-profit association ~1997.
• FIPA’s purpose is to promote the success of
emerging agent-based applications, services and
equipment by establishing standards
– MP3 was the model
• In 2006 it became an IEEE standards committee
FIPA Agent Communication Language
•
•
•
•
•
•
•
•
Called FIPA ACL
Based on speech acts
Messages are actions (communicative actions or CAs)
Communicative acts are described in both a narrative form
and a formal semantics based on modal logic
Syntax is similar to KQML
Specification provides a normative description of highlevel interaction protocols (aka conversations)
Separate library of protocols and content languages
(e.g., SL, KIF, RDF)
Several serializations
Agent-Standardization - FIPA
Cooperation between Agents
CAs for Information Exchange
• proposition or reference as content
• Basic CAs:
– inform
– query-ref
– not-understood
• Advanced CAs:
– inform-if, inform-ref
– confirm, disconfirm
– subscribe
Agent-Standardization - FIPA
Cooperation between Agents
CAs for task delegation
• action-description as content
• Basic CAs:
– request
– agree
– refuse
– failure
– not-understood
• Advanced CAs:
– request-when, request-whenever
– cancel
Agent-Standardization - FIPA
Cooperation between Agents
CAs for Negotiation
• action-description and proposition as content
• Initiating CA
– cfp
• Negotiating CA
– propose
• Closing CAs
– accept-proposal
– reject-proposal
Agent-Standardization - FIPA
Cooperation between Agents
Example
(request
:sender (:name [email protected]:3410)
:receiver (:name hilton_hotel@tcp://hilton.com:5001)
:ontology fipa-pta
:language SL
:protocol fipa-request
:content
( action hilton_hotel@tcp://hilton.com:5001
( book-hotel (:arrival 04/07/1999) (:departure 12/07/1999)
(:infos ( ))
)))
FIPA 99: other possibilities to define content!
Agent-Standardization - FIPA
Cooperation between Agents
FIPA Cooperation
• CAs have their own formal semantics
– difficult to implement
– need not be implemented - agent must behave
according to semantics
• Interaction protocols define structured
conversations
– based on CAs
– basis for dialogues between agents
– basic set of pre-defined IPs
– own IPs can be defined
Agent-Standardization - FIPA
Cooperation between Agents
FIPA-Query (simplified - for information exchange)
query
not-understood
inform
Agent-Standardization - FIPA
Cooperation between Agents
FIPA-Request - for task delegation
request(action)
not-understood
refuse(reason)
failure(reason)
inform(done())
agree
inform-ref
AUML
• Agent UML
• http://www.auml.org/
• ULM like framework
for specifying agent
communication and
interaction protocols
FIPA Agent Platform
software
A A
Agents belong to one or more
agent platforms which provide
basic services.
AMS
DF
ACC
IIOP
internal platform message transport
Jade
Java Agent Development
Framework is an OS software
framework for multi-agent systems,
implemented in Java.
– Developed by Telcom Italia
– Built on FIPA standards
– Libraries (LEAP) for handheld
and wireless devices
– http://jade.tilab.com/
System of choice for building
FIPA based MAS
April 2007
2000-?
Semantic Web
“XML is Lisp's bastard nephew, with uglier
syntax and no semantics. Yet XML is poised to
enable the creation of a Web of data that
dwarfs anything since the Library at
Alexandria.”
-- Philip Wadler, Et tu XML? The fall of
the relational empire, VLDB, Rome,
September 2001.
“The web has made people smarter. We
need to understand how to use it to make
machines smarter, too.”
-- Michael I. Jordan, paraphrased
from a talk at AAAI, July 2002
by Michael Jordan (UC Berkeley)
“The Semantic Web will globalize KR, just as
the WWW globalize hypertext”
-- Tim Berners-Lee
Origins
Tim Berners-Lee’s original 1989
WWW proposal described a web of
relationships among named
objects unifying many info.
management tasks.
Capsule history
• Guha’s MCF (~94)
• XML+MCF=>RDF (~96)
• RDF+OO=>RDFS (~99)
• RDFS+KR=>DAML+OIL (00)
• W3C’s SW activity (01)
• W3C’s OWL (03)
http://www.w3.org/History/1989/proposal.htm
W3C’s Semantic Web Goals
Focus on machine consumption:
"The Semantic Web is an extension of the current web in
which information is given well-defined meaning, better
enabling computers and people to work in cooperation."
-- Berners-Lee, Hendler and Lassila, The Semantic Web,
Scientific American, 2001
Agents?
• DARPA gave the Semantic Web a big push starting in
2000
– Going from simple RDF to OWL
• DARPA Agent Markup Language
• Goal was to give agents access to information and
knowledge
• And to populate the web with intelligent agents
providing services
TBL’s semantic web vision
RDF is the first SW language
Graph
XML Encoding
<rdf:RDF ……..>
<….>
<….>
</rdf:RDF>
Good for
Machine
Processing
RDF
Data Model
Triples
stmt(docInst, rdf_type, Document)
stmt(personInst, rdf_type, Person)
stmt(inroomInst, rdf_type, InRoom)
stmt(personInst, holding, docInst)
stmt(inroomInst, person, personInst)
Good For
Reasoning
Good For
Human
Viewing
RDF is a simple language
for building graph based
representations
Simple RDF Example
dc:Title
http://umbc.edu/
~finin/talks/idm02/
“Intelligent Information Systems
on the Web and in the Aether”
dc:Creator
bib:Aff
http://umbc.edu/
bib:name
“Tim Finin”
bib:email
“[email protected]”
XML encoding for RDF
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:bib="http://daml.umbc.edu/ontologies/bib/">
<description about="http://umbc.edu/~finin/talks/idm02/">
<dc:title>Intelligent Information Systems on the Web and in the
Aether</dc:Title>
<dc:creator>
<description>
<bib:Name>Tim Finin</bib:Name>
<bib:Email>[email protected]</bib:Email>
<bib:Aff resource="http://umbc.edu/" />
</description>
</dc:Creator>
</description>
</rdf:RDF>
A usecase: FOAF
• FOAF (Friend of a Friend) is a simple ontology to describe
people and their social networks.
– See the foaf project page: http://www.foaf-project.org/
• We recently crawled the web and discovered over 1,000,000
valid RDF FOAF files.
– Most of these are from the http://liveJournal.com/ blogging system which
encodes basic user info in foaf
– See http://apple.cs.umbc.edu/semdis/wob/foaf/
<foaf:Person>
<foaf:name>Tim Finin</foaf:name>
<foaf:mbox_sha1sum>2410…37262c252e</foaf:mbox_sha1sum>
<foaf:homepage rdf:resource="http://umbc.edu/~finin/" />
<foaf:img rdf:resource="http://umbc.edu/~finin/images/passport.gif" />
</foaf:Person>
FOAF: why RDF? Extensibility!
• FOAF vocabulary provides 50+ basic terms for
making simple claims about people
• FOAF files can use other RDF terms too: RSS,
MusicBrainz, Dublin Core, Wordnet, Creative
Commons, blood types, starsigns, …
• RDF guarantees freedom of independent extension
– OWL provides fancier data-merging facilities
• Result: Freedom to say what you like, using any
RDF markup you want, and have RDF crawlers
merge your FOAF documents with other’s and know
when you’re talking about the same entities.
After Dan Brickley, [email protected]
RDF Schema (RDFS)
• RDF Schema adds
taxonomies for
classes & properties
– subClass and
subProperty
• and some metadata.
– domain and range
constraints on
properties
• Several widely used
KB tools can import
and export in RDFS
Stanford Protégé KB editor
• Java, open sourced
• extensible, lots of plug-ins
• provides reasoning & server
capabilities
RDFS supports simple inferences
New and
Improved!
100% Better
than XML!!
• An RDF ontology plus some RDF statements may imply additional
RDF statements.
• This is not true of XML.
• Note that this is part of the data model and not of the accessing or
processing code.
@prefix rdfs: <http://www.....>.
@prefix : <genesis.n3>.
parent rdfs:domain person;
rdfs:range person.
mother rdfs:subProperty parent;
rdfs:domain woman;
eve mother cain.
parent a property.
person a class.
woman subClass person.
mother a property.
eve a person;
a woman;
parent cain.
cain a person.
W3C’s Web Ontology Language (OWL)
• DAML+OIL begat OWL.
• OWL released as W3C recommendation 2/10/04
• See http://www.w3.org/2001/sw/WebOnt/ for OWL
overview, guide, specification, test cases, etc.
• Three layers of OWL are defined of decreasing levels of
complexity and expressiveness
OWL
– OWL Full is the whole thing
– OWL DL (Description Logic) introduces
restrictions
– OWL Lite is an entry level language
intended to be easy to understand
and implement
OWL in One Slide
OWL is built on top of XML and RDF
It allows the definition, sharing,
composition and use of ontologies
OWL is ~= a frame based knowledge
representation language
It can be used to add metadata about
anything which has a URI.
URIs are a W3C standard generalizing
URLs
everything has a URI
<rdf:RDF xmlns:rdf ="http://w3.org/22-rdf-syntax-ns#"
xmlns:rdfs=http://w3.org/rdf-schema#>
xmlns:owl="http://www.w3.org/2002/07/owl#”>
<owl:Ontology rdf:about="">
<owl:imports rdf:resource="http://owl.org/owl+oil"/>
</owl:Ontology>
<owl:Class rdf:ID="Person">
<rdfs:subClassOf rdf:resource="#Animal"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasParent"/>
<owl:allValuesFrom rdf:resource="#Person"/>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf>
<owl:Restriction owl:cardinality="1">
<owl:onProperty rdf:resource="#hasFather"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
<Person rdf:about=“http://umbc.edu/~finin/">
<rdfs:comment>Finin is a person.</rdfs:comment>
</Person>
RDF is being used!
• RDF has a solid specification
• RDF is being used in a number of web standards
– CC/PP (Composite Capabilities/Preference Profiles), P3P (Platform for Privacy
Preferences Project), RSS (RDF Site Summary), RDF Calendar (~ iCalendar in
RDF)
• And in other systems
–
–
–
–
Netscape’s Mozilla web browser, open directory (http://dmoz.org/)
Adobe products via XMP (eXtensible Metadata Platform)
Web communities: LiveJournal, Ecademy, and Cocolog
In Microsoft’s VISTA: Connected Services Framework uses an RDF database
and SPARQL
– Oracle’s 10g and 11g products
– Yahoo’s food portal
– Joost TV over the web startup
SPARQL Example
BASE <http://example.org/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX ex: <properties/1.0#>
SELECT DISTINCT $person ?name $age
FROM <http://rdf.example.org/people.rdf>
WHERE { $person a foaf:Person ;
foaf:name ?name.
OPTIONAL { $person ex:age $age } .
FILTER ! REGEX(?name, "Bob")
}
LIMIT 3 ORDER BY ASC[?name]
Some applications
involving
ACLs and the
Semantic Web
ITTALKS Architecture
Web Services
Web server + Java
servlets
People
MapBlast, CiteSeer,
Google, …
HTTP
Email, HTML,
SMS, WAP
HTTP, WebScraping
Apache
Tomcat
Agents
FIPA ACL, KQML,
DAML
SQL
DB
RDBMS
<daml>
<daml>
<daml>
</daml>
<daml>
</daml>
</daml>
</daml>
Databases
DAML files
DAML
reasoning
engine
Travel Agent Game in Agentcities
Motivation
Features
Market dynamics
Auction theory (TAC)
Semantic web
Agent collaboration (FIPA &
Agentcities)
Open Market Framework
Auction Services
OWL message content
OWL Ontologies
Global Agent Community
Technologies
Ontologies
http://taga.umbc.edu/ontologies/
FIPA (JADE, April Agent Platform)
Semantic Web (RDF, OWL)
Web (SOAP,WSDL,DAML-S)
Internet (Java Web Start )
travel.owl – travel concepts
fipaowl.owl – FIPA content lang.
auction.owl – auction services
tagaql.owl – query language
Report Direct Buy Transactions
Report Contract
Report Auction Transactions
Market Oversight
Agent
Bulletin Board
Agent
Customer
Agent
Report Travel Package
Auction Service
Agent
Proposal
Direct Buy
Travel Agents
Web Service
Agents
FIPA platform infrastructure services, including directory facilitators enhanced to use DAML-S for service discovery
http://taga.umbc.edu/
Acknowledgements: DARPA contract F30602-00-2-0591 and Fujitsu Laboratories of America.
Students: Y. Zou, L. Ding, H. Chen, R. Pan. Faculty: T. Finin, Y. Peng, A. Joshi, R. Cost. 4/03
http://ebiquity.umbc.edu/
• Our research group’s web site
generate both HTML and OWL.
• HOW? This is relatively easy since
the content is in a database.
• PHP is sufficient for the job.
• HTML pages have links to
corresponding OWL
• WHY? This exposes the
information to programs and agents
– no more web scraping.
CMU MyCampus Project
•
•
Objective: Enhance campus life
through context-aware services
accessible over the WLAN
Ontologies
– Personal/contextual: location,
calendar, organizational etc.
– Privacy preferences: who has
access to what, “obfuscation”
rules
– Web services: automated service
identification and access (OWLS)
http://www.cs.cmu.edu/~sadeh/mycampus.htm#Video
Fujitsu Task Computing
• Objective: Make computing available
throughout the physical environment
while it is effectively invisible to the
users
e-Services
Aerial Photo of
Weather Info of
Web Pages
Play Jeff’s Video
Dial Contact from Outlook
Weather Info of FLA, CP
…
OS/Application
Device
Dial
Video from DV
Play (Audio)
Play (Video)
Devices
http://www.taskcomputing.org/
Open
Save
Print
View
Jeff’s Video
Add into Outlook
Contact from Outlook
OS/Application
The Context Broker Architecture
http://cobra.umbc.edu/
Access to more
information
Knowledge sharing
Policy
The EasyMeeting System
An EasyMeeting Scenario
People enter the
conference room
They “beam” their
policy to the broker
B
The broker detects
people presence
B
»»
»
Alice’s policy says,
“inform my personal
agent of my location”
B
.. isLocatedIn ..
A
The broker builds
the context model
Web
B
The broker tells her
location to her agent
A
An EasyMeeting Scenario
Her agent informs
the broker about her
role and intentions
+
The Greeting Srv. greets
Alice & the others
Hello! [xyz]
Alice’s policy says,
“can share with any
agents in the room”
The broker informs
the subscribed agents
B
A
When all expected
participants hv arrived
OFF
DIM
The projector agent
sets up the slides
The SOUPA Ontology
2010and Beyond
It's hard to make predictions,
especially about the future
Things to watch
• Google (e.g., GoogleBase)
• Wikipedia (e.g., Semantic MediaWiki)
• Freebase (OWL meets Wikipedia?)
• Joost – a high profile startup (internet meets
TV) is using RDF and considers it to be "XML
on steroids."
• If RDF is the new KIF, then SPARQL might
evolve into the new KQML
Conclusions
Some key ideas
• Software agents offer a new paradigm for very large scale
distributed heterogeneous applications.
• The paradigm focuses on the interactions of autonomous,
cooperating processes which can adapt to humans and
other agents.
• Agent Communication Languages are a key enabling
technology
– Mobility is an orthogonal characteristic which many, but not all,
consider central.
– Intelligence is always a desirable characteristic but is not strictly
required by the paradigm.
• The paradigm is still forming and ACLs will continue to
evolve.