Des architectures
et des langages orientés agents présentent des
limitations sur un certain nombre de points. Ils sont la plupart du
temps limités au type de modèle d'agent particulier
qu'ils développent. S'ils sont centrés agents, on
constate en termes de modèles une grande focalisation sur les
aspects de décision et des limitations sur les aspects sociaux.
On peut remarquer qu'une bonne partie des langages portent sur les
approches BDI (Belief-Desire-Intentions). D'autre part, les langages
d'interaction comme FIPA et KQML sont le plus souvent définis
indépendamment des modèles ou des types d'agents
utilisés, ce qui permet aux concepteurs de choisir leurs propres
architectures d'agents. Pourtant, on se trouve face à un dilemme
: soit on laisse le modèle d'agent totalement libre et on garde
un niveau d'abstraction très élevé et peu
opérationnel pour le langage (comme KQML), soit on fournit un
langage opérationnel mais qui contraint fortement le
modèle et la programmation des agents (comme AGENT0).
Afin
de
réaliser une
opérationalisation plus accessible des systèmes
multi-agents, des travaux ont tenté de réutiliser des
architectures et des langages existants pour construire des
environnements de développement de ces systèmes. Les
environnements de développement ou les plates-formes
multi-agents sont nécessaires pour renforcer le succès de
la technologie multi-agents. Les plates-formes multi-agents permettent
aux développeurs de concevoir et réaliser leurs
applications sans perdre de temps à réaliser des
fonctions de base pour la création et l'interaction entre agents
et éliminent, dans la plupart des cas, la
nécessité d'être familier avec les
différents concepts théoriques des systèmes
multi-agents.
Présentation
des plates-formes
Parmi les
plates-formes fournies comme logiciels libres, il y quelques
plates-formes plus connues pour avoir été
utilisées dans le développement de plusieurs applications
: JADE, ZEUS,
et MADKIT
pour les agents
cognitifs, et SWARM pour
les agents réactifs. Il faut noter que cette liste n'est pas
unique, et qu'il y a aussi d'autres plates-formes qui ont
été utilisées avec beaucoup de succès pour
bâtir diverses applications.
La plate-forme
multi-agents JADE sera présentée en détail dans la
section suivante. Les autres mentionnées ci- dessous vont
être présentées d'une manière
synthétique dans cette section même.
-
La
plate-forme JADE
:
JADE (Java Agent Development
Framework - Bellifemine, Poggi, Rimassa, 1999) est une plate-forme
multi-agents développée en Java par CSELT (Groupe de
recherche de Gruppo Telecom, Italie) qui a comme but la construction
des systèmes multi-agents et la réalisation
d'applications conformes à la norme FIPA (FIPA, 1997). JADE
comprend deux composantes de base : une plate-forme agents compatible
FIPA et un paquet logiciel pour le développement des agents Java.
Les premiers documents de
spécification de
la norme FIPA (FIPA 1997), appelés spécifications FIPA97,
établissent les règles normatives qui permettent à
une société d'agents d'inter-opérer. Tout d'abord,
les documents FIPA décrivent le modèle de
référence d'une plate-forme multi-agents (figure 6.3)
où ils identifient les rôles de quelques agents
clés nécessaires pour la gestion de la plate-forme, et
spécifient le contenu du langage de gestion des agents et
l'ontologie du langage.
Figure
1. Le modèle de
référence pour une
plate-forme multi-agents FIPA
Dans la figure 6.3, on voit qu'il y a trois rôles principaux dans
une plate-forme multi-agents FIPA :
Le standard spécifie aussi le Langage
de Communication d'Agents (Agent Communication Language -
ACL) . La communication des agents est basée sur l'envoi de
messages. Le langage FIPA ACL est le langage standard des messages et
impose le codage, la sémantique et la pragmatique des messages.
La norme n' impose pas de mécanisme spécifique pour le
transport interne de messages. Plutôt, puisque les agents
différents pourraient s'exécuter sur des plates-formes
différentes et utiliser technologies différentes
d'interconnexion, FIPA spécifie que les messages
transportés entre les plates-formes devraient être
codés sous forme textuelle. On suppose que l'agent est en mesure
de transmettre cette forme textuelle. La norme FIPA préconise
des formes communes pour les conversations entre agents par la
spécification de protocoles d'interaction, qui incluent des
protocoles simples de type requête-réponse, mais aussi des
protocoles spécifiques aux agents comme le réseau
contractuel et les enchères anglaises et hollandaises.
2.
L'environnement JADE
Le but de JADE est de simplifier
le
développement des systèmes multi-agents en
conformité avec la norme FIPA pour réaliser des
systèmes multi-agents inter-opérables. Pour atteindre ce
but, JADE offre la liste suivante de caractéristiques
au programmeur d'agents :
- La plate-forme
multi-agents compatible
FIPA, qui inclut le Système de Gestion d'Agents
(AMS), le Facilitateur d'Annuaire (DF), et le Canal de Communication
entre Agents (ACC) - voir la section précédente et la
figure 1. Ces trois agents sont automatiquement créés et
activés quand la plate-forme est activée.
- La plate-forme d'agents distribuée. La plate-forme
d'agents peut être distribuée sur plusieurs hôtes,
à condition qu'il n'y ait pas de pare-feu entre ces hôtes.
Une seule application Java, et donc une seule Machine Virtuelle Java,
est exécutée sur chaque hôte. Les agents sont
implémentés comme des threads d'exécution Java et
les événements Java sont utilisés pour la
communication efficace et légère entre agents sur un
même hôte. Un agent peut exécuter des tâches
parallèles et JADE planifie ces tâches d'une
manière plus efficace (et même plus simple pour le
programmeur) que la planification faite par la Machine Virtuelle Java
pour les threads d'exécution.
- Un certain nombre de DF (Facilitateurs d'Annuaire) compatibles
FIPA qui peuvent être activés quand on lance la
plate-forme pour exécuter les applications multi-domaines.
- Une interface de programmation pour simplifier l'enregistrement
de services d'agents avec un ou plusieurs domaines de type DF.
- Le mécanisme de transport et l'interface pour l'envoi et
la réception des messages.
- Le protocole IIOP compatible avec le document FIPA97 pour
connecter des plates-formes multi-agents différentes.
- Le transport léger de messages ACL sur la même
plate-forme d'agents. Dans le but de simplifier la transmission, les
messages internes (sur la même plate-forme) sont
transférés codés comme des objets Java et non
comme des chaînes de caractères. Quand l'expéditeur
ou le récepteur n'appartient pas à la même
plate-forme, le message est automatiquement converti à/du format
de chaîne de caractères spécifiés par la
FIPA. De cette façon, la conversion est cachée au
programmeur d'agents, qui a seulement besoin de traiter la classe
d'objets Java.
- Une bibliothèque de protocoles d'interaction compatibles
FIPA.
- L'enregistrement automatique d'agents dans le Système de
Gestion d'Agents (AMS).
- Un service d'attribution de noms compatible FIPA ; quand on lance
la plate-forme, un agent obtient un identificateur unique (Globally
Unique Identifier - GUID).
- Une interface graphique utilisateur pour gérer plusieurs
agents et plates-formes multi-agents en partant d'un agent unique.
L'activité de chaque plate-forme peut être
supervisée et enregistrée.
3.
L'architecture de la plate-forme
multi-agents
L'architecture du logiciel est
basée sur
la coexistence de plusieurs Machines Virtuelles (VM) Java et la
communication se fait par la méthode RMI (Remote Method
Invocation) de Java entre machines virtuelles (VMs) différentes.
Chaque VM est un réceptacle d'agents
qui fournit un environnement d'exécution complet pour
l'exécution des agents et permet d'avoir plusieurs agents qui
s'exécutent simultanément sur un même hôte.
En principe, l'architecture permet aussi à plusieurs VM
d'être exécutées sur le même hôte ;
cependant, ceci n'est pas à encourager, car on crée ainsi
un surcroît de travail au système qui n'apporte aucun
bénéfice. Chaque réceptacle d'agents est un
environnement multi- threads d'exécution composé d'un
thread d'exécution pour chaque agent et, en plus, des threads
créés à l'exécution par le système
RMI pour envoyer des messages. Un récipient spécial joue
le rôle du frontal de la plate-forme
; il contient les agents de gestion et représente la plate-forme
toute entière pour le monde extérieur.
Une plate-forme multi-agents JADE
est alors
composée de plusieurs réceptacles d'agents selon la
figure 2. La distribution de ces réceptacles à travers un
réseau d'ordinateurs est permise, à condition que la
communication RMI entre leurs hôtes soit conservée. Un
réceptacle léger spécial est
implémenté pour l'exécution des agents dans un
navigateur Web. Chaque réceptacle d'agents est un objet serveur
RMI qui gère localement un ensemble d'agents. Il règle le
cycle de vie des agents en les créant, les suspendant, les
reprenant et les détruisant. En plus, il traite tous les aspects
de la communication : répartition des messages ACL reçus,
routage des messages selon le champ de destination (:receiver) et
dépôt des messages dans les files de messages
privées des agents. Pour les messages vers l'extérieur,
le réceptacle d'agents maintient assez d'information pour
chercher l'emplacement de l'agent récepteur et pour choisir une
méthode de transport convenable pour expédier le message
ACL.
Figure 2. Architecture logicielle de la
plate-forme
multi-agents JADE
La plate-forme offre une interface graphique utilisateur (GUI) pour la
gestion à distance qui permet de contrôler et superviser
les états des agents, par exemple arrêter et remettre en
marche un agent. L'interface graphique permet aussi de créer et
de commencer l'exécution d'un agent sur un hôte
éloigné, à condition qu'un réceptacle
d'agents s'exécute déjà sur cet hôte.
L'interface elle-même a été
implémentée comme un agent, appelé RMA (Remote
Monitoring Agent). Toute la communication entre les agents et
l'interface (GUI) et toute la communication entre cette interface et
l'AMS est faite par ACL via une extension ad hoc de l'ontologie des
agents de gestion FIPA.
On a vu qu'une
propriété importante
d'un agent est son autonomie : un agent ne doit pas se limiter à
réagir aux événements externes, mais il doit
être aussi capable de prendre l'initiative de nouveaux actes
communicatifs d'une façon autonome. Ceci exige que chaque agent
ait un thread interne de contrôle ; cependant, un agent peut
engager des conversations simultanées multiples, tout en
poursuivant d' autres activités qui n'impliquent pas d'
échanges de messages.
JADE utilise l'abstraction Comportement
pour modéliser les tâches qu'un agent peut exécuter
et les agents instancient leurs comportements selon leurs besoins et
leurs capacités. De point de vue de la programmation
concurrente, un agent est un objet actif,
ayant un thread de contrôle. JADE utilise un modèle de
programmation concurrente "un thread-par-agent" au lieu d'un
modèle "un thread-par-comportement" pour éviter une
augmentation du nombre de threads d'exécution exigés sur
la plate-forme d'agents. Ceci signifie que, pendant que les agents
différents s'exécutent dans un environnement multi-
threads de préemption, deux comportements d'un même agent
sont planifiés coopérativement.
En dehors de la préemption,
les
comportements travaillent tous comme des threads d'exécution
coopératifs, mais il n'y a pas de pile qui ait besoin
d'être sauvée. Un planificateur (scheduler),
exécuté par la classe de base Agent et
caché au programmeur, exécute une politique de
"round-robin" de non-préemption entre tous les comportements
disponibles dans la file des processus prêts. Ainsi, il permet
l'exécution d'une classe dérivée de la classe
Comportement jusqu'à ce qu'elle abandonne le contrôle
d'exécution par elle-même. Si la tâche qui a le
contrôle n'est pas encore finie, elle sera re-planifiée
pendant le prochain tour du round-robin à moins qu'elle ne soit
pas bloquée ; en fait, un comportement peut se bloquer
lui-même, par exemple pendant qu'il attend des messages, pour
éviter le gaspillage de temps de CPU, réalisant ainsi un
comportement d'attente occupée.
Donc, le développeur
d'agents doit
étendre la classe Agent et implémenter les tâches
spécifiques de l'agent par une ou plusieurs classes
Comportement, les instancier et les ajouter à l'agent. La classe
Agent représente une super-classe commune pour tous les agents
définis par l'utilisateur. Du point de vue du programmeur, la
conséquence est qu'un agent JADE est simplement une classe Java
qui étend la classe de base Agent. Cela permet à l'agent
d'hériter un comportement fondamental caché (qui traite
toutes les tâches liées à la plate-forme, telles
que l'enregistrement, la configuration, la gestion à distance,
etc.), et un ensemble de méthodes qui peuvent être
appelées pour implémenter les tâches
spécifiques à l'agent, par exemple envoi des messages,
utilisation des protocoles d'interaction standard, enregistrement sur
plusieurs domaines, etc. De plus, il y a encore deux méthodes
qui sont héritées pour gérer la file de
comportements d'agents : addBehaviour(Behaviour) et
removeBehaviour(Behaviour). JADE inclut aussi quelques comportements
prêts à être utilisés pour les tâches
les plus communes dans la programmation des agents, tels que l'envoi et
la réception des messages et la décomposition des
tâches complexes en des agrégations de tâches plus
simples. Entre autres, JADE offre aussi une classe JessBehaviour qui
permet l'intégration avec le système expert JESS (Java
Expert System Shell), où JADE fournit le noyau de l'agent et
garantit (autant que possible) la conformité avec les normes
FIPA, alors que JESS est le moteur d'inférence de l'agent qui
exécute le raisonnement nécessaire pour la
résolution du problème.
Autres
plates-formes :
MACE (Gasser e.a., 1987) :
C'est le
premier environnement de conception et d'expérimentation
de différentes architectures d'agents dans divers domaines
d'application. Dans MACE, un agent est un objet actif qui communique
par envoi de messages. Les agents existent dans un environnement qui
regroupe tous les autres agents et toutes les autres entités du
système. Un agent peut effectuer trois types d'actions : changer
son état interne, envoyer des messages aux autres agents et
envoyer des requêtes au noyau MACE pour contrôler les
événements internes. Chaque agent est doté d'un
moteur qui représente la partie active de l'agent. Ce moteur
détermine l'activité de l'agent et la façon dont
les messages sont interprétés. MACE a été
utilisé pour développer des simulations d'applications
distribuées.
ZEUS (Nwama
e.a., 1999) :
C'est une
plate-forme multi-agents conçue et réalisée par
British Telecom (Agent Research Programme of BT Intelligent Research
Laboratory) pour développer des applications collaboratives.
ZEUS est écrit dans le langage Java et il est fondé sur
les travaux de la FIPA. L'architecture des agents ZEUS est similaire
à la majorité des agents collaboratifs. Elle regroupe
principalement les composantes suivantes :
L'environnement comporte trois bibliothèques :
une avec des
agents utilitaires, une avec des outils pour la construction des
agents, et une avec des composants agents.
ZEUS met un fort accent sur la méthodologie de
développement, fondée sur la notion de rôle . Elle
a été
utilisé pour développer plusieurs applications
réelles comme les ventes aux enchères et la simulation de
la fabrication des ordinateurs. Les caractéristiques des
domaines d'applications de ZEUS ont été définies
par les concepteurs ; parmi ces caractéristiques, on peut
mentionner :
MADKIT
(Madkit,
2003) :
C'est
une
plate-forme développée par le Laboratoire d'Informatique,
de Robotique et de Microélectronique de Montpellier (LIRMM) de
l'Université Montpellier II. MADKIT est libre pour l'utilisation
dans l'éducation. MADKIT est écrit en Java et est
fondé sur le modèle organisationnel Alaadin. Il utilise
un moteur d'exécution où chaque agent est construit en
partant d'un micro-noyau. Chaque agent a un rôle et peut
appartenir à un groupe. Il y a un environnement de
développement graphique qui permet facilement la construction
des applications.
SWARM (Minar
e.a., 1996) :
C'est une
plate-forme multi-agents avec agents réactifs. L'inspiration du
modèle d'agent utilisé vient de la vie artificielle.
SWARM est l'outil privilégié de la communauté
américaine et des chercheurs en vie artificielle.
L'environnement offre un ensemble de bibliothèques qui
permettent l'implémentation des systèmes multi-agents
avec un grand nombre d'agents simples qui interagissent dans le
même environnement. De nombreuses applications ont
été développées à partir de SWARM
qui existe aujourd'hui implémenté en plusieurs langages
(Java, Objective-C).
Bibliographie
- Booch, C. Object-Oriented Analysis and Design with Applications,
Addison-Wesley, Reading, MA, 1994.
- Booch, C., J. Rumbaugh, I. Jacobson. The Unified Modelling
Language User Guide, Addison-Wesley, MA, 1998.
- Bousquet, F., C. Le Page. Systèmes multi-agents et
écosystèmes. Dans Principes et architectures des
systèmes multi-agents, J.P. Briot et Y. Demazeau
(éditeurs), Hermès, Lavoisier, 2001, p. 235-258.
- Briot, J.P., Y. Demazeau (éditeurs). Principes et
architectures des systèmes multi-agents, Hermès,
Lavoisier, 2001.
- Gasser, L., C. Braganza, N. Herman. MACE: A flexible testbed for
distributed AI, Pitman, 1987.
- Guessoum, Z., M. Occello. Environnements de développement.
Dans Principes et architectures des systèmes multi-agents, J.P.
Briot et Y. Demazeau (éditeurs), Hermès, Lavoisier, 2001,
p.177-202.
- Iglesias, C., e.a. Analysis and design of multiagent systems
using MAS-CommonKADS. In Proc. of AAAI'97, Workshop on Agent Theories,
Architectures and languages, Providence, RI, 1997.
- Iglesias, C., M. Garijo, J.C. Gonzalez. A survey of
agent-oriented methodologies. In Proc. of ATAL, the 5th International
Workshop on Agent theories, Architectures and languages, Paris, 4-7
July, 1998, p.185-198.
- Jacobson, I. e.a. Object-Oriented Software Engineering. A Use
case Driven Approach. ACM Press, 1992.
- Jennings, N. R. On agent-based software engineering. Artificial
Intelligence, Vol. 117, No.2, 2000, p.277-296.
- Jennings, N. R., M. Wooldridge. Agent-Oriented Software
Engineering. Dans Handbook of Agent Technology, Ed. J. Bradshaw,
AAAI/MIT Press. 2001.
- Minar, N. e.a. The swarm simulation system: a toolkit for
building multi-agent simulations, 1996,
http://www.santafe.edu/project/swarm
- Nwama, H., e.a. Zeus: A toolkit for building distributed
multi-agent systems. Applied Artificial Intelligence Journal, vol.13,
no.1, 1999, p.129-186.
- Rational Software Corporation. Unified Modelling Language (UML),
version 1.0, 1997.
- Rumbaugh, I. e.a. Object Oriented Modeling and Design,
Prentice-Hall, 1991.
- Sandholm, T.W., V.R. Lesser. Coalitions among computationally
bounded agents. Artificial Intelligence, 94 (1-2), 1997, p. 99-137.
- Schreiber, A.T., e.a. CommonKADS: A comprehensive methodology for
KBS development. Technical Report DM1.2a, Univ. of Amsterdam,
Netherlands Research Foundation ECN and Free Univ. of Brussels, 1994.
- Shehory, O., S. Kraus. Methods for task allocation via agent
coalition formation. Artificial Intelligence, Vol. 101, Nr.1-2, 1998,
165-200
- Wooldridge, M. An Introduction to MultiAgent Systems, John Wiley
& Sons, 2002.
- Wooldridge, M., G. Weiss, P. Ciancarini (eds). Agent-Oriented
Software Engineering II - Actes de "2nd International Workshop",
AOSE-2001, LNCS Volume 2222, Springer, Berlin, 2001.
- Wooldridge, M., N.R. Jennings. Intelligent agents: Theory and
practice. Knowledge Engineering Review Vol. 10, No. 2, 1995, p.115-152.
- Bellifemine, F., A. Poggi, G. Rimassa. JADE - A FIPA-compliant
agent framework. CSELT internal technical report, et dans Actes de
PAAM'99, London, Avril 1999, p..97-108.
Webliographie
- OMG. The Object Management Group, http://www.omg.org/
- AUML. The Agent Unified Modelling language, http://www.auml.org/
- FIPA: Foundation for Intelligent Physical Agents. Specifications.
1997. http://www.fipa.org
- Plate-forme JADE: Java Agent Development Framework, 2000. http://jade.cselt.it/
- Java Expert System Shell (JESS) http://herzberg.ca.sandia.gov/jess/
- Plate-forme ZEUS http://www.labs.bt.com/projects/agents/zeus
- Plate-forme MADKIT, 2003 http://www.madkit.org
- Plate-forme SWARMS http://www.swarm.org/index.html
- Une présentation des plates-formes et environnements pour
la construction des systèmes multi-agents http://epfl.ch/~iagents/Slides/lecture2_v1.1.ppt
- Liste plates-formes multi-agents
http://www.agentlink.org/resources/agent-software.php
- Liste plates-formes multi-agents commerciales
http://www.agentbuilder.com/AgentTools/commercial.php
- Liste plates-formes multi-agents logiciel libre
http://www.agentbuilder.com/AgentTools/academic.php
Equipes
de
recherches
Tony
Garneau & Sylvain Delisle
Département
de mathématiques et d informatique Université du
Québec
à Trois-Rivières 3351 boulevard des Forges,
Trois-Rivières Québec, Canada, G9A 5H7
Programmation
orientée-agent : évaluation comparative d outils et
environnements
http://www.uqtr.ca/dmasbuilder/download/documents/JFIADSMA2002.pdf
------------------------------------------------------------------------------
DMAS
Builder :
Distributed
MultiAgent System Builder
http://www.uqtr.ca/dmasbuilder/
-----------------------------------------------------------------
Groupe
ARCHITECTURES ET MODÈLES POUR L'INTERACTION
Jean-Paul
Sansonnet
Plateformes
multi-agents et outils pour le travail collaboratif
http://www.limsi.fr/RS2002FF/CHM2002FF/AMI2002FF/ChapAmi.html
-----------------------------------------------------------------
Ecole
Doctorale SPMI - Rouen/ Le Havre
LIH
- Laboratoire d Informatique du Havre
A.
Cardon, C. Bertelle et D. Olivier
Modélisation
et implémentation des systèmes complexes Mise en
oeuvre des systèmes multi- agents Exemples de plateformes
http://www-lih.univ-lehavre.fr/~olivier/Enseignement/DEA/cours/support/cours7.pdf
-------------------------------------------------------------------
GEAMAS
Stéphane
Calderoni, Rémy Courdier et Jean-Dany Vally
mas2@univ-reunion.fr
Equipe
MAS2
IREMIA
- Université de la Réunion
http://www.univ-reunion.fr/~mas2/
GEAMAS
est une plate-forme logicielle générique pour la
modélisation et la simulation multi-agents, entièrement
implémentée en Java, qui fonctionne sous Unix, MacOS et
Windows. Encore à l?état de prototype, cette
plate-forme nourrit deux objectifs : elle constitue une base
logicielle expérimentale, en évolution permanente, pour
les besoins de recherche de l?équipe, mais elle participe
également à l?intégration des techniques
multi-agents dans des projets scientifiques de la Zone Océan
Indien
http://www-poleia.lip6.fr/~guessoum/asa/afia/geamas.html
---------------------------------------------------------------------
Magique
P
Mathieu, N Bensaid, JC Routier
Équipe
SMAC
LIFL
- UPRESA 8022 CNRS - Bat. M3
Université
de Lille 1
59655
VILLENEUVE D'ASCQ CedexFRANCE
Contact
: mathieu@lifl.fr
Magique
se base sur une communauté de hiérarchies d'agents qui
permet une totale maîtrise de la granularité du
contrôle.Une originalité du modèle est de
permettre aux agents d'exploiter de manière transparente (ie.
sans qu'ils sachent qui l'accomplira) toutes les compétences
des différents agents du système.
http://www-poleia.lip6.fr/~guessoum/asa/afia/magique.html
------------------------------------------------------------------
La
plate-forme MASK
Michel
Occello,Christof Baeijs, Jean-Luc Koning, Yves Demazeau
Equipe
MAGMA
LEIBNIZ-IMAG-CNRS
GRENOBLE
Contact
: Michel.Occello@imag.fr
MASK
(Multi-Agent System Kernel) est un environnement de
développement
de SMA en cours de développement depuis 1993 dans
l'équipe
MAGMA du laboratoire LEIBNIZ/IMAG/CNRS de Grenoble. Elle est
fondée
sur l?approche d?Analyse / Conception Voyelle (AEIO) [4] etconstitue
le support logiciel de cette méthode.
http://www-poleia.lip6.fr/~guessoum/asa/afia/mask.html
------------------------------------------------------------------
La
plate-forme MAST ( Multi Agent System Toolkit)
O.
Boissier, P. Beaune, C. Sayettat, T. Carron, F. Gaultier, M. Hannoun,
H. Proton, L. Vercouter.
Equipe
SMA/Ecole Nationale Supérieure des Mines de Saint-Etienne
Contact
: OIivier.Boissier@emse.fr
MAST
est actuellement en cours de développement. Une première
maquette a été utilisée pour développer
quelques applications tests à l Université de São
Paulo et au sein du laboratoire. Ecrite en Java (1.2), elle permet d
intégrer différents langages tels que Jess, Clips, C++,
Prolog, Tcl/tk. Elle s exécute sur stations SUN et PCs, sous
Solaris 2.x, Linux ou Windows.
http://www-poleia.lip6.fr/~guessoum/asa/afia/mast.html
-----------------------------------------------------------------
La
plate-forme MERCURE
Xavier
Briffault1, Romuald Coeffier2, Olivier Ferret1, Nicolas Guichard1,
Pascal Héraud2, Jean-Philippe Kotowicz1, Sébastien
Landeau2, Denis Pierre2, Christophe Roche3, Gérard Sabah1,
Jérôme Saelen2, Jérôme Vapillon1
LIMSI-CNRS1
AEGIS2
LGIS3
Contact
: briffault@limsi.fr
La
plate-forme multi-agents MERCURE est une plate-forme
générique
en cours de développement dans le cadre d?une collaboration
entre le LIMSI-CNRS (groupe Langage et Cognition), la
société
AEGIS et le LGIS, au sein du projet EUREKA PVS98. Cette plate-forme
est globalement conforme aux spécifications architecturales
proposées par la FIPA (Foundation for Intelligent Physical
Agents, http://www.fipa.org/spec/index.html ), et a d?ailleurs
été
choisie récemment par cet organisme pour
développer
une application de démonstration de l?intérêt des
SMA (aide à la gestion de réunions). Il s?agit d?un
prototype d?environnement commercial de développement de SMA,
développé en Smalltalk, sur lequel quelques petites
applications ont été testées. Elle est
essentiellement destinée au développement de
systèmes
d?informations d?entreprises.
http://www-poleia.lip6.fr/~guessoum/asa/afia/mercure.html
------------------------------------------------------------------------
La
plate-forme OSACA
Jean-Paul
Barthès
Université
de Technologie de Compiègne
BP
20529, F-60205 Compiègne / France
Contact
: barthes@asterix.gi.utc
La
plate-forme OSACA a été développée par
Edson Scalabrin et Jean-Paul Barthès à l'UTC entre 1992
et 1996. Elle a servi à programmer quelques exemples simples,
et a été utilisée par Weiming Shen comme support
de son système DIDE environnement de conception en
ingénierie
concourante).Le type d'application visé est celui faisant
intervenir un petit nombre d'agents cognitifs complexes, l'idée
étant que chaque agent possède sa propre machine (dans
le cas de DIDE un agent peut être par exemple un programme de
calcul de type éléments finis). OSACA a été
développée sur station UNIX en Lisp et C (et ILU).
http://www-poleia.lip6.fr/~guessoum/asa/afia/osaca.html