Apologies for some broken links:
we failed to ensure that some files whose owners left had been preserved.
Some External Pointers to the ToolkitThis toolkit is referenced at various web sites. A sample found with the help of google is listed here.
(Apologies for broken links: Probably quite out of date now.)
Unlike many so-called 'agent toolkits', like PRS/Jack, Mozart, Alice, and several more, that are aimed mainly at development of systems involving large numbers of highly distributed fairly homogeneous relatively 'small' agents, SimAgent can be used for such purposes (and was used in that way for a while by Matthias Scheutz at Notre Dame University) but (like ACT-R, COGENT, and the original SOAR) SimAgent is primarily designed to support design and implementation of very complex agents, each composed of very different interacting components (like a human mind) where the whole thing is embedded in an environment that could be a mixture of physical objects and other agents of many sorts, as half-jokingly depicted here:
For example the main motivation behind the development of SimAgent was originally to support research on an increasingly complex sequence of agent types, that led to the development of the biologically inspired CogAff architecture Schema depicted in the image below, showing layers of sophistication superimposed on different types of functionality represented by the columns:
The CogAff Architecture Schema
That schema accommodates a wide variety of specific architecture types, which differ according to which mechanisms and information structures occur in which boxes, and how they are connected to one another and to the environment, as described in this overview.
The simplest architectures (e.g. microbe-like or insect-like agents) use only the bottom (purely reactive) layer of the CogAff schema, whereas more sophisticated architectures use all the layers (the top ones are the ones that evolved latest).
The above diagram is misleading in various ways because it suggest that the perception mechanisms and action mechanisms are separate from each other and can only communicate via the 'central' mechanisms, whereas it is clear (as James Gibson pointed out in his 1966 book The Senses Considered as Perceptual Systems) action and perception are deeply integrated, e.g. the constant use of saccades, changes of vergence, changes of focus in vision, and the need to move your hand when it is used to perceive shape, texture, weight, flexibility, hardness, etc. of objects.
So a more accurate, but less clear depiction of the ideas in the CogAff architecture schema is the following (with thanks to Dean Petters, for help with this diagram):
Revised, more realistic CogAff Architecture Schema,
e.g. with deeper integration between action and perception
The horizontal discs represent (usually "fuzzy" boundaries between
different levels of functionality. It is possible for some of the
information-processing mechanisms to straddle two or more layers.
A different view showing how action and perception are integrated,
as pointed out by J.J.Gibson in 1966
A slightly different, possibly clearer presentation of the same ideas as above.
A special case is the conjectured human-like H-CogAff architecture depicted in a sketchy manner below, with components described in more detail in the overview and in papers and presentations on the CogAff web site:
So far nothing as complex as that has been implemented, though various
fragments have been, by collaborators, research fellows and PhD students.
Some of our undergraduates and MSc students have
also used various parts of the toolkit, e.g. the 'Popracer' undergraduate
Examples of the 2-D graphical interface tools available can be found here
Examples of movies demonstrating the toolkit can be found here:
The toolkit is available as part of Poplog in the FreePoplog
The most widely used version is for 32-bit Linux (though there is also a 64 bit version).
(includes download instructions).
Also available for non-linux users (e.g. MSWindows, or Mac) in a Virtual Box Package
Because of its implementation using Pop11 in Poplog it is relatively light weight, and teaching demos and student projects have been run on linux machines with only 64MB RAM. Of course, the amount of memory required at run time depends on what is built with it.
The download package is under 20MB and when installed occupies a directory of less than 90MB -- the exact size depending on the number and type of saved images created. (The defaults include images for running Prolog, Common Lisp, and Standard ML.)
The total size can be much smaller, if unwanted languages in Poplog, the system sources, and documentation are removed, e.g. for running on a small robot.
External libraries, e.g. for vision, or for speech generation (e.g. using 'espeak' on linux) can add to the size required.
The OpenPoplog project aims to port the full functionality to Windows+PC. However, with the use of virtualisation, e.g. using the VmWare environment or VMFusion or VirtualBox, full Linux Poplog, including SimAgent with graphics, can run under both Windows and Apple OSX (on Intel-based Macs), as illustrated here: http://www.cs.bham.ac.uk/research/projects/poplog/ova/
The CogAff project paper directory includes papers reporting on theoretical work and preliminary designs. There are also slide presentations (in PDF and Postscript) presenting the theoretical ideas including a slide presentation on the SimAgent toolkit: http://www.cs.bham.ac.uk/~axs/misc/talks#simagent
Some mpeg movies illustrating simple uses of the toolkit can be found here http://www.cs.bham.ac.uk/research/poplog/figs/simagent/
Although SimAgent was originally developed to simulate multiple agents and/or individual agents with multiple concurrently active interacting sub-mechanisms, it was mainly used on a single CPU (although some users haVE distributed processes communicating via sockets). More recently there have been two developments supporting distributed versions of SimAgent
It was important for us that the toolkit did not embody a commitment to a particular type of agent architecture, since the whole point was to support exploration of a variety of architectures.
We also required a development environment supporting rapid prototyping (to help with clarifying ill-defined problems), incremental compilation, changes to code without having to restart a process, support for a wide variety of AI techniques and programming styles, and tools for graphical tracing via displays of a running simulation, and graphical interaction via a mouse -- sometimes described as "direct manipulation".
We wanted it to be easy to do fairly simple things, while also supporting more complex and difficult programming tasks.
As a result of analysing requirements implicit in some of our theoretical work (described in papers in the "Cogaff" project directory, and in some of our conference and seminar presentations) a set of ideas for a toolkit emerged. The first draft was made available in October 1994, and a paper about it presented at ATAL95. Since then there have been several extensions. Some of these arose from suggestions made by Jeremy Baxter and Richard Hepplewhite who were using the toolkit for their work on simulated army agents at DERA Malvern. Their work is briefly summarised in a panel alongside a paper on Sim_agent, in Communications of the ACM, March 1999.
Pop-11 is a multi-paradigm, extendable, incrementally compiled language, very similar in power and diversity to Common Lisp, but with a more conventional syntax and some other differences. E.g. it has no interpreter, only an incremental compiler.
Here are some of the programming paradigms we felt were necessary for our architectural explorations:
Allowing rules that operate on internal databases within agents to be contained in those databases also makes it easier to design agents that develop new capabilities, or agents which can be dynamically extended via new "plug-ins").
The use of the language Pop-11 makes it far easier to combine all these paradigms than if we had used any other language, apart from Common Lisp.
The current version of the toolkit is very general and flexible, though perhaps not as easy to use as a toolkit dedicated to a particular type of architecture.
For applications requiring a graphical interface, e.g. displaying moving simulated agents, or with buttons, sliders, menus, control-panels, etc. the RCLIB package is available. There is a library which links RCLIB to Sim_agent, called SIM_PICAGENT.
(Note: RCLIB is an object-oriented extension of the old RC_GRAPHIC package providing 'Relative Coordinate' Graphical facilities. All drawing is relative to a changeable coordinate frame, allowing scale-changes, zooming in and out, moving windows into a simulation, etc.)
By default sim_agent runs as a single process within which multiple "threads" manage different objects and agents and also different components within the "minds" of individual agents. It can also be used in distributed mode, using the Pop-11 socket mechanism to support communication between instances of sim_agent.
Poplog and Pop-11 previously formed part of an expensive commercial
product, but they are now available,
with full sources, courtesy of the Sussex University.
Sim_agent is available at the same site.
Information about teaching materials for programming and AI in Poplog can be found here. ("Poplog" is a trade mark of the University of Sussex.)
There are additional users in the list of referrers to SimAgent
The news files report extensions and bug-fixes.
E.g. extensions in July 1999 made it easier to use the toolkit to create agents which can observe and alter their own processing architecture. These changes are described in the NEWKIT document listed below.
More recent extensions proposed partly by Steve Allen and Catriona Kennedy allowed rules more easily to access databases of other agents, and extended the facilities for self-monitoring. See the NEWS files listed below.
Some older documents:
It is a plain text file, designed for viewing in the Poplog editor VED. It includes code that can be copied and run, if you have a Poplog system and have fetched the toolkit from the Birmingham Poplog ftp site.
A different tutorial, the the TEACH SIM_DEMO code produced some of the demonstration "movies", described below.
a very general, flexible and extendable interpreter for condition-action rules, written in Pop-11. It is based on the idea of a forward-chaining production system interpreter, but provides a collection of unusual facilities, including a smooth interface to neural net or other "sub-symbolic" mechanisms, through so-called "filter" conditions, a wide variety of condition types and action types (both user-extendable), and a variety of control options and higher level structuring facilities.
Poprulebase allows rulesets to be combined into rulefamilies. Within a rulefamily, control can be transferred between rulesystems as the context changes. This also allows SOAR-like pushing and popping of contexts, as well as other sorts of transitions. Rulefamilies can be combined into rulesystems. Each agent has a rulesystem, which may be an arbitrarily complex collection of interacting rulesets and rulefamilies, with associated databases providing memory stores and communication channels.
2. The Sim_agent library
provides a set of base classes and scheduling mechanisms for running simulations involving a number of objects and agents whose internal mechanisms are implemented as multiple rulesets or rulefamilies, using Poprulebase. Sim_agent also makes use of the object oriented facilities provided in the Pop-11 Objectclass package, a CLOS-like extension to Pop-11 providing multiple-inheritance, generic functions, etc. Objectclass, which was designed and implemented by Steve Knight at HP Research Labs, Bristol, turns Pop-11 into a powerful language for designing re-usable extendable software modules, as CLOS does for Lisp.
In sim_agent, each agent has its own rulesystem which may consist of a collection of rulesets and rulefamilies implementing a variety of mechanisms (perception, memory, motive generation, planning, self-monitoring, etc.). A feature of the toolkit is provision for differing resource allocation between components of an agent, and between agents. E.g. some agents may plan quickly relative to their perceptual processes, others slowly.
3. The RCLIB package: This extends the Pop-11 RC_GRAPHIC facility and provides flexible new tools for building graphical demonstrations and complex graphical control panels.
Examples of displays produced by the "RCLIB" Graphic Library can be found in http://www.cs.bham.ac.uk/research/poplog/figs/rclib/
For more information on Pop-11 and Poplog see:
A user of linux on a PC (x86 or x86_64) can fetch everything required from here.
The following sub-packages are available for download separately.
Code and documentation for the Poprulebase package can be found in a browsable directory..
The main documentation files for Poprulebase (in plain ascii text) are in the PRB/HELP sub-directory.
The tutorial documentation (in plain ascii text) is in the PRB/TEACH sub-directory.
There is also a compressed tar file for Poprulebase.
Most of poprulebase can be used without SimAgent or RCLIB.
Code and documentation for SIM_AGENT is in a browsable directory, and also in a compressed tar file. This cannot be used without Poprulebase. Some of the examples with graphical interfaces also require RCLIB.
The main overview documentation for SIM_AGENT (in plain ascii text) is in the SIM/HELP sub-directory.
The tutorial documentation (in plain ascii text) is in the SIM/TEACH sub-directory.
3. The RCLIB graphical library
The graphical libraries used in some of the demonstration code can be found in the "rclib" extension to Pop-11's rc_graphic library, which provides a sophisticated object oriented graphical extension to Pop-11 including 2-D drawing, movable objects, buttons, sliders (not just horizontal and vertical) etc.
The Pop-11 Objectclass system was crucial for the development of both RCLIB and the SIM_AGENT mechanisms. Objectclass provides multiple inheritance and generic functions, extending Pop-11 roughly as CLOS extends Common Lisp. It was originally designed and implemented by Steve Leach when he was at Hewlett Packard research labs. He is now a freelance software engineer. He made many other contributions to the design as a user, while at Hewlett Packard, some of which are part of poplog, others in libraries at the Poplog web site.
Objectclass makes it easy to introduce new types of agents sharing some default methods with the top level agent class while providing their own extensions. This was also a requirement for the graphical tools. Objectclass also made it easy to combine agent classes with graphical object classes to produce agents which both act in a simulated world and also display their activity in a 2-D graphical display, where they can be manipulated with the mouse.
Code and documentation for objectclass are part of the Poplog system.
Thanks to Chris Glur for pointing out typos.
Additional funding came from the University of Birmingham (1994-5).
Our collaborators at DERA provided funding which partly contributed to development of the toolkit between 1994 and 1998.
The whole package continues to improve (partly on the basis of suggestions from users), while every effort is made to retain `backward compatibility'. Comments and criticisms are welcome and may be addressed to me.
School of Computer Science, The University of Birmingham,
Birmingham, B15 2TT,
EMAIL: A.Sloman AT cs.bham.ac.uk
This file is maintained by:
Last updated: 30 May 2005; 27 Jan 2010; 31 Aug 2014 (reformat, and some minor corrections and additions.)