| |
Next
Previous
Contents
Also known as intelligent software agents or just agents, this
area of AI research deals with simple applications of small
programs that aid the user in his/her work. They can be mobile
(able to stop their execution on one machine and resume it on
another) or static (live in one machine). They are usually
specific to the task (and therefore fairly simple) and meant
to help the user much as an assistant would. The most popular
(ie. widely known) use of this type of application to date are
the web robots that many of the indexing engines
(eg. webcrawler) use.
- AgentK
This package synthesizes two well-known agent paradigms:
Agent-Oriented Programming, Shoham (1990), and the Knowledge Query
& Manipulation Language, Finin (1993). The initial implementation
of AOP, Agent-0, is a simple language for specifying agent
behaviour. KQML provides a standard language for inter-agent
communication. Our integration (which we have called Agent-K)
demonstrates that Agent-0 and KQML are highly compatible. Agent-K
provides the possibility of inter-operable (or open) software agents,
that can communicate via KQML and which are programmed using the AOP
approach.
- Agent
The Agent is a prototype for an Information Agent system. It is
both platform and language independent, as it stores contained
information in simple packed strings. It can be packed and shipped
across any network with any format, as it freezes itself in its
current state.
- agentTool
Another Java based agent development framework. Fairly unique in that
it emphasizes the use of a GUI for designing the system which will
"semi-automatically synthesize multiagent systems to meet those
requirements". You need a java enabled browser to download. :P
- Aglets Workbench
An aglet is a Java object that can move from one host on the
Internet to another. That is, an aglet that executes on one host can
suddenly halt execution, dispatch to a remote host, and resume
execution there. When the aglet moves, it takes along its program code
as well as its state (data). A built-in security mechanism makes it
safe for a computer to host untrusted aglets. The Java Aglet API
(J-AAPI) is a proposed public standard for interfacing aglets and
their environment. J-AAPI contains methods for initializing an aglet,
message handling, and dispatching, retracting,
deactivating/activating, cloning, and disposing of the aglet. J-AAPI
is simple, flexible, and stable. Application developers can write
platform-independent aglets and expect them to run on any host that
supports J-AAPI.
- A.L.I.C.E.
The ALICE software implements AIML (Artificial Intelligence Markup
Language), a non-standard evolving markup language for creating chat
robots. The primary design feature of AIML is minimalism. Compared with
other chat robot languages, AIML is perhaps the simplest. The pattern
matching language is very simple, for example permitting only one
wild-card ('*') match character per pattern. AIML is an XML language,
implying that it obeys certain grammatical meta-rules. The choice of
XML syntax permits integration with other tools such as XML editors.
Another motivation for XML is its familiar look and feel, especially to
people with HTML experience.
- Ara
Ara is a platform for the portable and secure execution of
mobile agents in heterogeneous networks. Mobile agents in this
sense are programs with the ability to change their host machine
during execution while preserving their internal state. This
enables them to handle interactions locally which otherwise had
to be performed remotely. Ara's specific aim in comparison to
similar platforms is to provide full mobile agent functionality
while retaining as much as possible of established programming
models and languages.
- Bee-gent
Bee-gent is a new type of development framework in that it is a 100%
pure agent system. As opposed to other systems which make only some use
of agents, Bee-gent completely "Agentifies" the communication that
takes place between software applications. The applications become
agents, and all messages are carried by agents. Thus, Bee-gent allows
developers to build flexible open distributed systems that make optimal
use of existing applications.
- Bond
Yet another java agent system...
Bond is a Java based distributed object system and agent framework. It
implements a message based middleware and associated services like
directory, persistence, monitoring and security. Bond allows to easily
build multi agent, distributed applications. Another application of
Bond will be a Virtual Laboratory supporting data annotation and
metacomputing.
- D'Agent (was AGENT TCL)
A transportable agent is a program that can migrate from machine
to machine in a heterogeneous network. The program chooses when and
where to migrate. It can suspend its execution at an arbitrary point,
transport to another machine and resume execution on the new machine.
For example, an agent carrying a mail message migrates first to a
router and then to the recipient's mailbox. The agent can perform
arbitrarily complex processing at each machine in order to ensure that
the message reaches the intended recipient.
- FIPA-OS
FIPA-OS is an open source implementation of the mandatory elements
contained within the FIPA specification for agent interoperability. In
addition to supporting the FIPA interoperability concepts, FIPA-OS also
provides a component based architecture to enable the development of
domain specific agents which can utilise the services of the FIPA
Platform agents. It is implemented in Java.
- Bots
Another AI-robot battle simulation. Utilizing probablistic logic as a
machine learning technique. Written in C++ (with C++ bots).
- Cadaver
Cadaver is a simulated world of cyborgs and nature in realtime. The
battlefield consists of forests, grain, water, grass, carcass (of
course) and lots of other things. The game server manages the game and
the rules. You start a server and connect some clients. The clients
communicate with the server using a very primitive protocol. They can
order cyborgs to harvest grain, attack enemies or cut forest. The game
is not intended to be played by humans! There is too much to control.
Only for die-hards: Just telnet to the server and you can enter
commands by hand. Instead the idea is that you write artificial
intelligence clients to beat the other artificial intelligences. You
can choose a language (and operating system) of your choice to do that
task. It is enough to write a program that communicates on standard
input and standard output channels. Then you can use programs like
"socket" to connect your clients to the server. It is NOT needed to
write TCP/IP code, although i did so :) The battle shall not be boring,
and so there is the so called spyboss client that displays the action
graphically on screen.
- Dunce
Dunce is a simple chatterbot (conversational AI) and a language for
programming such chatterbots. It uses a basic regex pattern matching
and a semi-neural rule/response firing mechanism (with excitement/decay
cycles).
Dunce is listed about halfway down the page.
- FishMarket
FM - The FishMarket project conducted at the Artificial Intelligence
Research Institute (IIIA-CSIC) attempts to contribute in that direction
by developing FM, an agent-mediated electronic auction house which has
been evolved into a test-bed for electronic auction markets. The
framework, conceived and implemented as an extension of FM96.5 (a
Java-based version of the Fishmarket auction house), allows to define
trading scenarios based on fish market auctions (Dutch auctions). FM
provides the framework wherein agent designers can perform controlled
experimentation in such a way that a multitude of experimental market
scenarios--that we regard as tournament scenarios due to the
competitive nature of the domain-- of varying degrees of realism and
complexity can be specified, activated, and recorded; and trading
(buyer and seller) heterogeneous (human and software) agents compared,
tuned and evaluated.
- Grasshopper
Another Java agent system. Full featured and actively developed.
Commercial, but free. Historically targeted at embedded systems.
- Hive
Hive is a Java software platform for creating distributed applications.
Using Hive, programmers can easily create systems that connect and use
data from all over the Internet. At its heart, Hive is an environment
for distributed agents to live, communicating and moving to fulfill
applications. We are trying to make the Internet alive.
- ICM
The Inter-Agent Communication Model (ICM) is a communication mechanism
that can be used for sending messages between agents in an asynchronous
fashion. Its intended application area is as a transportation mechanism
for agent communication languages (ACLs), such as KQML and FIPA's ACL.
- Jacomma
Jacomma is an agent development platform/framework for developing
distributed, mobile, and reactive information agents with heterogeneous
communication capabilities, in Java and JPython.
Jacomma provides a development framework and an execution environment,
which sits on top of the Inter-Agent Communication Model
infrastructure. The ICM defines a communication protocol, a store and
forward messaging architecture, and low level communication
infrastructure for message exchange. Communication is truly
asynchronous, based on TCP sockets.
ICM has an entry in this howto, or you can find it via a link off the
site.
- Jade
JADE (Java Agent DEvelopment Framework) is a software framework fully
implemented in Java language. It simplifies the implementation of
multi-agent systems through a middle-ware that claims to comply with
the FIPA specifications and through a set of tools that supports the
debugging and deployment phase. The agent platform can be distributed
across machines (which not even need to share the same OS) and the
configuration can be controlled via a remote GUI. The configuration can
be even changed at run-time by moving agents from one machine to
another one, as and when required.
- JAFMAS
JAFMAS provides a framework to guide the coherent development of
multiagent systems along with a set of classes for agent
deployment in Java. The framework is intended to help beginning
and expert developers structure their ideas into concrete agent
applications. It directs development from a speech-act
perspective and supports multicast and directed communication,
KQML or other speech-act performatives and analysis of
multiagent system coherency and consistency.
Only four of the provided Java classes must be extended for any
application. Provided examples of the N-Queens and Supply Chain
Integration use only 567 and 1276 lines of additional code
respectively for implementation.
- JAM Agent
JAM supports both top-down, goal-based reasoning and bottom-up
data-driven reasoning. JAM selects goals and plans based on maximal
priority if metalevel reasoning is not used, or user-developed
metalevel reasoning plans if they exist. JAM's conceptualization of
goals and goal achievement is more classically defined (UMPRS is more
behavioral performance-based than truly goal-based) and makes the
distinction between plans to achieve goals and plans that simply encode
behaviors. Goal-types implemented include achievement (attain a
specified world state), maintenance (re-attain a specified world
state), and performance. Execution of multiple simultaneous goals are
supported, with suspension and resumption capabilities for each goal
(i.e., intention) thread. JAM plans have explicit precondition and
runtime attributes that restrict their applicability, a postcondition
attribute, and a plan attributes section for specifying
plan/domain-specific plan features. Available plan constructs include:
sequencing, iteration, subgoaling, atomic (i.e., non-interruptable)
plan segments, n-branch deterministic and non-deterministic conditional
execution, parallel execution of multiple plan segments, goal-based or
world state-based synchronization, an explicit failure-handling
section, and Java primitive function definition through building it
into JAM as well as the invocation of predefined (i.e., legacy) class
members via Java's reflection capabilities without having to build it
into JAM.
- JATLite
JATLite is providing a set of java packages which makes easy to
build multi-agent systems using Java. JATLite provides only
light-weight, small set of packages so that the developers can
handle all the packages with little efforts. For flexibility
JATLite provides four different layers from abstract to Router
implementation. A user can access any layer we are
providing. Each layer has a different set of assumptions. The
user can choose an appropriate layer according to the
assumptions on the layer and user's application. The
introduction page contains JATLite features and the set of
assumptions for each layer.
- JATLiteBeans
- Improved, easier-to-use interface to JATLite features
including KQML message parsing, receiving, and sending.
- Extensible architecture for message handling and agent
"thread of control" management
- Useful functions for parsing of simple KQML message content
- JATLiteBean supports automatic advertising of agent
capabilities to facilitator agents
- Automatic, optional, handling of the "forward" performative
- Generic configuration file parser
- KQML syntax checker
- Java(tm) Agent Template
The JAT provides a fully functional template, written entirely in
the Java language, for constructing software agents which communicate
peer-to-peer with a community of other agents distributed over the
Internet. Although portions of the code which define each agent are
portable, JAT agents are not migratory but rather have a static
existence on a single host. This behavior is in contrast to many other
"agent" technologies. (However, using the Java RMI, JAT agents could
dynamically migrate to a foreign host via an agent resident on that
host). Currently, all agent messages use KQML as a top-level protocol
or message wrapper. The JAT includes functionality for dynamically
exchanging "Resources", which can include Java classes (e.g. new
languages and interpreters, remote services, etc.), data files and
information inlined into the KQML messages.
- Java-To-Go
Java-To-Go is an experimental infrastructure that assists in the
development and experimentation of mobile agents and agent-based
applications for itinerative computing (itinerative computing:
the set of applications that requires site-to-site
computations. The main emphasis here is on a easy-to-setup
environment that promotes quick experimentation on mobile
agents.
- Kafka
Kafka is yet another agent library designed for constructing
multi-agent based distributed applications. Kafka is a
flexible, extendable, and easy-to-use java class library for
programmers who are familiar with distributed programming. It
is based on Java's RMI and has the following added features:
- Runtime Reflection:
Agents can modify their behaviour (program codes) at
runtime. The behaviour of the agent is represented by an
abstract class Action. It is useful for remote maintenance or
installation services.
- Remote Evaluation:
Agents can receive and evaluate program codes (classes)
with or without the serialized object. Remote evaluation is a
fundamental function of a mobile agent and is thought to be a
push model of service delivery.
- Distributed Name Service:
Agents have any number of logical names that don't contain the host
name. These names can be managed by the distributed directories.
- Customizable security policy:
a very flexible, customizable, 3-layered security model is
implemented in Kafka.
- 100% Java and RMI compatible:
Kafka is written completely in Java. Agent is a Java RMI
server object itself. So, agents can directly communicate with
other RMI objects.
- Khepera Simulator
Khepera Simulator is a public domain software package written by
Olivier MICHEL
during the preparation of his Ph.D. thesis, at the Laboratoire I3S,
URA 1376 of CNRS and University of Nice-Sophia Antipolis, France. It
allows to write your own controller for the mobile robot Khepera using
C or C++ languages, to test them in a simulated environment and
features a nice colorful X11 graphical interface. Moreover, if you own
a Khepera robot, it can drive the real robot using the same control
algorithm. It is mainly oriented toward to researchers studying autonomous
agents.
- lyntin
Lyntin is an extensible Mud client and framework for the creation of
autonomous agents, or bots, as well as mudding in general. Lyntin is
centered around Python, a dynamic, object-oriented, and fun programming
language and based on TinTin++ a lovely mud client.
- Mole
Mole is an agent system supporting mobile agents programmed in
Java. Mole's agents consist of a cluster of objects, which have
no references to the outside, and as a whole work on tasks given
by the user or another agent. They have the ability to roam a
network of "locations" autonomously. These "locations" are an
abstraction of real, existing nodes in the underlying
network. They can use location-specific resources by
communicating with dedicated agents representing these
services. Agents are able to use services provided by other
agents and to provide services as well.
- Narval
Narval is the acronym of "Network Assistant Reasoning with a Validating
Agent Language". It is a personal network assistant based on artificial
intelligence and agent technologies. It executes recipes (sequences of
actions) to perform tasks. It is easy to specify a new action using XML
and to implement it using Python. Recipes can be built and debugged
using a graphical interface.
- NeL
NeL is actually a game development library (for massive multi-player
games), but I'm including it here as it (will) include a fairly
sizable AI library. Here's a blurb from the whitepaper:
The purpose of the AI library is to provide a pragmatic approach to
creating a distributed agents platform. Its focus is agents; individual
entities that communicate regardless of location, using an
action-reaction model.
- Penguin!
Penguin is a Perl 5 module. It provides you with a set of functions which
allow you to:
- send encrypted, digitally signed Perl code to a remote machine to be
executed.
- receive code and, depending on who signed it, execute it in an
arbitrarily secure, limited compartment.
The combination of these functions enable direct Perl coding of
algorithms to handle safe internet commerce, mobile
information-gathering agents, "live content" web browser helper
apps, distributed load-balanced computation, remote software
update, distance machine administration, content-based
information propagation, Internet-wide shared-data applications,
network application builders, and so on.
- RealTimeBattle
RealTimeBattle is a programming game, in which robots controlled by
programs are fighting each other. The goal is to destroy the enemies,
using the radar to examine the environment and the cannon to shoot.
- Game progresses in real time, with the robot programs
running as child processes to RealTimeBattle.
- The robots communicate with the main program using the
standard input and output.
- Robots can be constructed in almost any programming language.
- Maximum number of robots can compete simultaneously.
- A simple messaging language is used for communication, which
makes it easy to start constructing robots.
- Robots behave like real physical object.
- You can create your own arenas.
- Highly configurable.
- Remembrance Agents
Remembrance Agents are a set of applications that watch over a user's
shoulder and suggest information relevant to the current situation.
While query-based memory aids help with direct recall, remembrance
agents are an augmented associative memory. For example, the
word-processor version of the RA continuously updates a list of
documents relevant to what's being typed or read in an emacs buffer.
These suggested documents can be any text files that might be relevant
to what you are currently writing or reading. They might be old emails
related to the mail you are currently reading, or abstracts from papers
and newspaper articles that discuss the topic of your writing.
- SimRobot
SimRobot is a program for simulation of sensor based robots in a
3D environment. It is written in C++, runs under UNIX and X11 and
needs the graphics toolkit XView.
- Simulation of robot kinematics
- Hierarchically built scene definition via a simple definition
language
- Various sensors built in: camera, facette eye, distance
measurement, light sensor, etc.
- Objects defined as polyeders
- Emitter abstractly defined; can be interpreted e.g. as
light or sound
- Camera images computed according to the raytracing or
Z-buffer algorithms known from computer graphics
- Specific sensor/motor software interface for communicating
with the simulation
- Texture mapping onto the object surfaces: bitmaps in various
formats
- Comprehensive visualization of the scene: wire frame w/o
hidden lines, sensor and actor values
- Interactive as well as batch driven control of the agents
and operation in the environment
- Collision detection
- Extendability with user defined object types
- Possible socket communication to e.g. the Khoros image
processing software
- Sulawesi
A framework called Sulawesi has been designed and implemented to
tackle what has been considered to be important challenges in a
wearable user interface. The ability to accept input from any
number of modalities, and perform if necessary a translation to any
number of modal outputs. It does this primarily through a set
of proactive agents to act on the input.
- TclRobots
TclRobots is a programming game, similar to 'Core War'. To play
TclRobots, you must write a Tcl program that controls a robot. The
robot's mission is to survive a battle with other robots. Two, three,
or four robots compete during a battle, each running different
programs (or possibly the same program in different robots.) Each
robot is equipped with a scanner, cannon, drive mechanism. A single
match continues until one robot is left running. Robots may compete
individually, or combine in a team oriented battle. A tournament
can be run with any number of robot programs, each robot playing every
other in a round-robin fashion, one-on-one. A battle simulator is
available to help debug robot programs.
The TclRobots program provides a physical environment, imposing
certain game parameters to which all robots must adhere. TclRobots
also provides a view on a battle, and a controlling user interface.
TclRobots requirements: a wish interpreter built from Tcl 7.4 and Tk
4.0.
- TKQML
TKQML is a KQML application/addition to Tcl/Tk, which allows Tcl
based systems to communicate easily with a powerful agent
communication language.
- The Tocoma Project
An agent is a process that may migrate through a computer network
in order to satisfy requests made by clients. Agents are an attractive
way to describe network-wide computations.
The TACOMA project focuses on operating system support for agents and
how agents can be used to solve problems traditionally addressed by
operating systems. We have implemented a series of prototype systems
to support agents.
TACOMA Version 1.2 is based on UNIX and TCP. The system supports
agents written in C, Tcl/Tk, Perl, Python, and Scheme (Elk). It is
implemented in C. This TACOMA version has been in public domain since
April 1996.
We are currently focusing on heterogeneity, fault-tolerance, security
and management issues. Also, several TACOMA applications are under
construction. We implemented StormCast 4.0, a wide-area network
weather monitoring system accessible over the internet, using TACOMA
and Java. We are now in the process of evaluating this application,
and plan to build a new StormCast version to be completed by June
1997.
- Ummon
Ummon is an advanced Open Source chatterbot. The main principle of the
bot is that it has no initial knowledge of either words or grammar; it
learns everything "on the fly." Numerous AI techniques will be explored
in the development of Ummon to achieve realistic "human" communication
with support for different, customizable personalities.
- UMPRS Agent
UMPRS supports top-down, goal-based reasoning and selects goals and
plans based on maximal priority. Execution of multiple simultaneous
goals are supported, with suspension and resumption capabilities for
each goal (i.e., intention) thread. UMPRS plans have an integrated
precondition/runtime attribute that constrain their applicability.
Available plan constructs include: sequencing, iteration, subgoaling,
atomic (i.e., non-interruptable) blocks, n-branch deterministic
conditional execution, explicit failure-handling section, and C++
primitive function definition.
- Virtual Secretary Project (ViSe)
(Tcl/Tk)
The motivation of the Virtual Secretary project is to construct
user-model-based intelligent software agents, which could in
most cases replace human for secretarial tasks, based on modern
mobile computing and computer network. The project includes two
different phases: the first phase (ViSe1) focuses on information
filtering and process migration, its goal is to create a secure
environment for software agents using the concept of user
models; the second phase (ViSe2) concentrates on agents'
intelligent and efficient cooperation in a distributed
environment, its goal is to construct cooperative agents for
achieving high intelligence. (Implemented in Tcl/TclX/Tix/Tk)
- VWORLD
Vworld is a simulated environment for research with autonomous
agents written in prolog. It is currently in something of an
beta stage. It works well with SWI-prolog, but should work with
Quitnus-prolog with only a few changes. It is being designed to
serve as an educational tool for class projects dealing with
prolog and autonomous agents. It comes with three demo worlds or
environments, along with sample agents for them. There are
two versions now. One written for SWI-prolog and one written for
LPA-prolog. Documentation is roughly done (with a
student/professor framework in mind), and a graphical interface
is planned.
- WebMate
WebMate is a personal agent for World-Wide Web browsing and
searching. It accompanies you when you travel on the internet
and provides you what you want.
Features include:
- Searching enhancement, including parallel search, searching
keywords refinement using our relevant keywords extraction technology,
relevant feedback, etc.
- Browsing assistant, including learning your current interesting,
recommending you new URLs according to your profile and selected
resources, monitoring bookmarks of Netscape or IE, sending the current
browsing page to your friends, etc.
- Offline browsing, including downloading the following pages from
the current page for offline browsing.
- Filtering HTTP header, including recording http header and all
the transactions between your browser and WWW servers, etc.
- Checking the HTML page to find the errors or dead links, etc.
- Programming in Java, independent of operating system, runing in
multi-thread.
- Zeus
The construction of multi-agent systems involves long development
times and requires solutions to some considerable technical
difficulties. This has motivated the development of the ZEUS
toolkit, which provides a library of software components and tools
that facilitate the rapid design, development and deployment of
agent system
Next
Previous
Contents
|
