Core Technologies: Agent Factory
Agent Factory is a modular and extensible framework that provides comprehensive support for the development and deployment of agent-oriented applications. It has been developed by researchers from PRISM Laboratory in the School of Computer Science and Informatics at University College Dublin. It is part of an ongoing research initiative that seeks to understand how agent technologies may be used to construct complex distributed systems in a diverse range of problem domains, including, mobile computing, ubiquitous computing, distributed sensor networks, social robotics, and augmented reality.
Agent Factory is implemented in Java, and as can be seen in the above schematic, it is broadly decomposed into three parts:
- Run-Time Environment (RTE): A standards compliant layer that consists of a set of modular and extensible agent platforms that can be easily customised to each target applications needs.
- AF Deployment Process: An informal deployment process that facilitates the specification of agent system deployments, and supports the definition of both the configuration of each individual agent platform, and the initial distribution of the agent community.
- Development Kits: that provide necessary support for the development of specific types of agents based on individual agent architectures and programming languages.
A powerpoint presentation outlining details of Agent Factory can be found here.
1.1 Key Features:
- Broadly compliant with the current FIPA Standards.
- Adopts a "Plug and Play" Philosophy that supports:
- Deployment of multiple agent types potentially employing a diverse set of agent architectures and programming languages.
- Configuration of multiple platform services within each agent platform, including Agent Management Services, and Message Transport Services.
- Support for run-time debugging, logging, remote management, and visualisation tools.
- Off the shelf application infrastructures that can be integrated into any agent application.
- Run-time is deployable on J2SE and J2ME CDC supported devices.
- End-to-end support for agent development through the AFAPL Development Kit.
- Tool-based support integrated with well-established IDE's such as Eclipse and Netbeans.
1.2 Download:
Agent Factory is open source and available under the Lesser General Public License (LGPL) from SourceForge.
2. The Agent Factory Agent Programming Language (AFAPL)
AFAPL is a high-level language for specifying agent behaviours based on multi-modal logic of commitment. This logic models agents as entities that have a mental state which consists of:
- Beliefs: The current state of the world
- Plans: Possible courses of action that the agent may follow
- Commitments: The courses of action that the agent has decided to follow
- Commitment Rules: Situations in which new commitments should be adopted
The language itself is declarative, and programs are executed on a purpose-built agent interpreter that implements a core state transition algorithm that transforms a valid mental state into a new valid mental state. Specifically, the underlying algorithm performs the following operations:
- Perception: Build a new belief model based on a snapshot of the current state of the agents environment.
- Commitment Adoption: Check the commitment rules against the new belief model to see if any new commitment should be adopted.
- Commitment Management: Evaluate the current commitments, checking:
- which ones have been completed
- which ones failed
- which ones should be acted upon (realised or refined), and
- which ones are no longer achievable (i.e. should not be maintained).
- Action: Perform any outstanding actions.
To constrain the duration of the above algorithm, the Agent Factory Run-Time Environment implements a global scheduler. This scheduler allots time slices to agents, and notifies the agent when that time slot has ended.
In addition, to the above mental stat architecture, an AFAPL agent implementation also includes a number of Java-based components:
- Perceptors: generate beliefs about the current state of the environment
- Actuators: implement the primitive actions of the agent
- Modules: Private internal resources that the agent can use to store data
Finally, support for reuse through a C-style #include mechanism.
3. Future Work
Ongoing work aims to address a number of ongoing issues within the agent community. ,including: the development of testing and verification environments for agent implementations; the construction of new application infrastructures that support the deployment of systems that employ morecomplex organisational structures; the creation of tools to support debugging and visualisation of large-scale agent systems; and the definition of new agent programming languages that offer enhanced robustness, reasoning, adaptivity, and reuse.
4. Selected Publications
- R. Collier. Debugging Agents in Agent Factory. In Programming Multi-Agent Systems, Lecture Notes in Artificial Intelligence (LNAI), Volume 4411, Springer-Verlag, 2006. [ PDF ]
- R. Collier, R. Ross, G.M.P. O'Hare. Realising Reusable Agent Behaviours with ALPHA. In Multiagent System Technologies, Lecture Notes in Artificial Intelligence (LNAI), Volume 3550, Springer-Verlag, 2005. [ PDF ]
- R. Ross, G.M.P. O'Hare, R. Collier. AF-APL: Bridging Principles and Practice in Agent-Oriented Languages. In Programming Multi-Agent Systems, Lecturer Notes in Artificial Intelligence (LNAI), Volume 3346, Springer-Verlag, 2004. [ PDF ]
- R. Collier, C.F.B. Rooney, G.M.P. O'Hare. A UML-based Software Engineering Methodology for Agent Factory. In Proceedings of the 16th International Conference on Software Engineering and Knowledge Engineering (SEKE-2004), Banff, Alberta, Canada, 20-25th June, 2004. [ PDF ]
- R. Collier, G.M.P. O'Hare, T. Lowen, C.F.B. Rooney. Beyond Prototyping in the Valley of the Agents. In Multi-Agent Systems and Applications III, Lecture Notes in Computer Science (LNCS 2691), Springer-Verlag, 2003. [ PDF ]
|
