You are on page 1of 205

Agent and Multi-Agent Programming

Olivier Boissier1 , Rafael H. Bordini2 ,
Jomi F. Hübner3 , Alessandro Ricci4
1 EMSE, France 2 PUC-RS, Brazil
Olivier.Boissier@emse.fr R.Bordini@pucrs.br

3 DAS-UFSC, Brazil 4 University
of Bologna, Italy
jomi@das.ufsc.br a.ricci@unibo.it

Outline of the seminar
Introduction
AOP
About Agent Oriented Programming
Jason
EOP
About Environment Oriented Programming
A&A and CArtAgO
OOP
About Organisation Oriented Programming
Moise
Putting the pieces together: JaCaMo

Introduction

Introduction AOP EOP OOP Conclusion

Abstractions in Multi-Agent Systems
schema

mission
role ORGAMISATION
org
LEVEL

agent

AGENT
LEVEL

artifact ENDOGENOUS
ENVIRONMENT
wsp
LEVEL

EXOGENOUS
ENVIRONMENT
4 / 200

Organisational Rules: constraints on roles and their interactions... . regulation patterns Roles: rights. coordination. situatedness Cognitive Concepts: beliefs. . reactive/pro-active behaviour Environment Level: resources and services that agents can access and control. goals. responsibilities. Introduction AOP EOP OOP Conclusion Abstractions in Multi-Agent Systems Individual Agent Level: autonomy. desires... intentions. plans Reasoning Cycle: sense/reason/act. deadlines. sensing and acting in an environment Social and Organisation Level: cooperation. norms. Organisational Structures: topology of interaction patterns and relations over activity control 5 / 200 .

but still not a mature paradigm Programming languages/platforms for organisation and environment are also being developed Some agent development platforms have a formal basis Many influenced by the BDI agent architecture 6 / 200 . Introduction AOP EOP OOP Conclusion Agent Oriented Programming Proposed by Shoham [Shoham. 1993] Use of mentalistic notions and a societal view of computation (anthropomorphism) Levels of abstraction: Agents – Organisations – Environment Programming languages for agents have developed a lot since then.

Isreal. Introduction AOP EOP OOP Conclusion BDI Architecture Intentional Stance (Dennett) Practical Reasoning (Bratman) IRMA (Bratman. Lansky) dMARS (Kinny) BDI Logics and Agent Architecture (Rao.. . 7 / 200 . Singh. Pollack) PRS (Georgeff.. Georgeff) Wooldridge.

Jadex. Golog variants.g. GOAL. Agent Factory.. 2APL. Introduction AOP EOP OOP Conclusion Programming Languages for Cognitive Agents Programming Languages for Multi-Agent Systems E. Architecture to represent an agent mental state: Beliefs: information available to agent (e. Brahms. . Jason. JACK. MetateM... about the environment or other agents) Goals: states of affairs that the agent wants to achieve Events: changes in agents beliefs or goals Capabilities: reusable modules of activities that the agent can perform Plans: reasoning about courses of action to achieve goals Rules: reasoning about beliefs 8 / 200 .g. JIAC..

The architecture and reasoning cycle together with the agent program (specially plans) determine the behaviour of the agent. 9 / 200 . Introduction AOP EOP OOP Conclusion Programming Languages for Cognitive Agents Some steps of a Reasoning Cycle: Determining Relevant Plans for Handling Events Select a Plan for Execution Execute Part of an Intended Plans Handle Plan Failures Agent Interpreter is an infinite loop of such reasoning cycles.

Groups Norms. Sanctions. Rewards Management Infrastructure to control and coordinate agent behaviour at run-time: Endogenous: The control is a part of the agent program Exogenous: The control is performed by an external system Monitoring Agent Behaviour Enforcing Organisational Rules Regimenting Organisational Rules 10 / 200 . Violations Dependency. Power. Delegation. Permissions. Prohibitions. Roles. Information flow relations Deadlines. Obligations. Introduction AOP EOP OOP Conclusion Programming Languages/Platforms for Organisations Concepts used to specify the state of an organisation: Agents.

Coordination. i.. Introduction AOP EOP OOP Conclusion Programming Languages/Platforms for Environments Artifacts to represent the state of the environment Access to Databases/Services/etc..e. non-proactive entities Processing Operations on Artifacts Realising the effects of environments actions Providing events related to sensing the environment Synchronising agent actions At the right level of abstraction for a multi-agent system 11 / 200 . Interaction Environment “objects”.

net http://cartago.sourceforge. unified platform covering the 3 main levels of abstractions for multi-agent oriented programming JaCaMo = Jason + CArtAgO + Moise http://jacamo. Introduction AOP EOP OOP Conclusion Putting the Pieces Together: JaCaMo First fully operational.net http://jason.net More than the sum of 3 successful platforms Revealing the full potential of Multi-Agent Oriented Programming 12 / 200 .sourceforge.sourceforge.sourceforge.net http://moise.

AOP .

Outline 2 AOP: Agent Oriented Programming About AOP Jason Introduction to Jason Reasoning Cycle Main Language Constructs: Beliefs. Goals. and Plans Other Language Features Comparison With Other Paradigms The Jason Platform Perspectives: Some Past and Future Projects Conclusions .

About AOP .

Plan Organisation: Group. Norm. Percepts. Interactions Environment: Artifacts. Introduction AOP EOP OOP Conclusion About AOP Jason Agent Oriented Programming Use of mentalistic notions and a societal view of computation [Shoham. Actions 16 / 200 . Goal. Role. 1993] Heavily influence by the BDI architecture and reactive planning systems Various language constructs for the sophisticated abstractions used in AOSE Agent: Belief. Intention.

Introduction AOP EOP OOP Conclusion About AOP Jason Agent Oriented Programming Features Reacting to events × long-term goals Course of actions depends on circumstance Plan failure (dynamic environments) Rational behaviour Social ability Combination of theoretical and practical reasoning 17 / 200 .

2009]. 2006a]. 2007c].. 2009] Proceedings: ProMAS. 2004] Surveys: [Bordini et al.. 2007b. 2008b... 2APL [Dastani. Languages of historical importance: Agent0 [Shoham. 2005a].. 2006.. GOAL [Hindriks. 1993].. Hindriks et al. Leite et al. Dastani et al. 2008a. Golog [Giacomo et al. [Baldoni et al.. . Introduction AOP EOP OOP Conclusion About AOP Jason Literature Books: [Bordini et al.. 2005b. 2007] . Dastani et al. 2006. 3APL [Hindriks et al..... 2000] Other prominent languages: Jason [Bordini et al. 2009... Bordini et al. 2005] But many others languages and platforms.. Leite et al.... 2005]. [Bordini et al.. 2005.. AgentSpeak(L) [Rao.. 2006b. 1997]. Baldoni et al. 2005]. Bordini et al... 2008. 2009.... Baldoni et al. 1996]. Bordini et al. 18 / 200 . Baldoni et al. [Fisher et al. DALT. 2010. 2004. Baldoni and Endriss. 2008a]. JACK [Winikoff. 2010. Dastani et al.. LADS. Dastani et al. Jadex [Pokahr et al. MetateM [Fisher.

.. . Pokahr). . McCabe). STAPLE (Kumar. FLUX (Thielscher).).. . Bach (John Lloyd. . JADE (Agostino Poggi.. . Huber). Agentis (Agentis Software).. Meyer. .. CLAIM (Amal El Fallah-Seghrouchni.. Dix. . Hindriks. Toni. Kraus... Bordini.. Stathis. van Riemsdijk..). 3APL and 2APL (Dastani. MetateM (Fisher. Levesque... GOAL (Hindriks).)... Eiter). . SemantiCore (Blois..). . . Introduction AOP EOP OOP Conclusion About AOP Jason Some Languages and Platforms Jason (Hübner. JACK (AOS). Guidini.). JIAC (Hirsch..)..).. BRAHMS (Sierhuis.). ..). Jackdaw (Calico Jack)..).. Jadex (Braubach. Hirsch. Go! (Clark.).. . . / Boutilier – DTGolog). SOCS (Torroni. Cohen. ... Teamcore/ MTDP (Milind Tambe. MINERVA (Leite... ConGoLog (Lesperance.. IMPACT (Subrahmanian.). 19 / 200 .

.. etc. tracing of agents’ mental attitudes.) and an MAS Programming Language! Many agent languages have efficient and stable interpreters — used extensively in teaching All have some programming tools (IDE. Introduction AOP EOP OOP Conclusion About AOP Jason The State of Multi-Agent Programming Already the right way to implement MAS is to use an AOSE Methodology (Prometheus. Tropos. Gaia. tracing of messages exchanged.) Finally integrating with social aspects of MAS Growing user base 20 / 200 ..

Jason .

dMARS (Kinny). based on logic programming Inspired by PRS (Georgeff & Lansky). 1996] Programming language for BDI agents Elegant notation. and BDI Logics (Rao & Georgeff) Abstract programming language aimed at theoretical results 22 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason AgentSpeak The foundational language for Jason Originally proposed by Rao [Rao.

communication. Hbner and Rafael H.g. Bordini 23 / 200 . definition of the MAS...) Highly customised to simplify extension and experimentation Developed by Jomi F. Introduction AOP EOP OOP Conclusion About AOP Jason Jason A practical implementation of a variant of AgentSpeak Jason implements the operational semantics of a variant of AgentSpeak Has various extensions aimed at a more practical programming language (e. .

representing the agent’s know-how Events: happen as consequence to changes in the agent’s beliefs or goals Intentions: plans instantiated to achieve some goal 24 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason Main Language Constructs and Runtime Structures Beliefs: represent the information available to an agent (e.g. about the environment or other agents) Goals: represent states of affairs the agent wants to bring about Plans: are recipes for action.

Introduction AOP EOP OOP Conclusion About AOP Jason Main Architectural Components Belief base: where beliefs are stored Set of events: to keep track of events the agent will have to handle Plan library: stores all the plans currently known by the agent Set of Intentions: each intention keeps track of the goals the agent is committed to and the courses of action it chose in order to achieve the goals for one of various foci of attention the agent might have 25 / 200 .

Introduction AOP EOP OOP Conclusion About AOP Jason Jason Interpreter Basic Reasoning cycle perceive the environment and update belief base process new messages select event select relevant plans select applicable plans create/update intention select intention to execute 26 / 200 .

..send Intentions Push New Messages Suspended Intentions Intentions Intention sendMsg (Actions and Msgs) New Plan . Updated Intention 27 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason Jason Rreasoning Cycle Belief Agent Beliefs Base 5 1 2 Events Percepts Percepts SE Plan perceive BUF BRF Library External External Selected Events Events Events Beliefs Event 4 7 Relevant 6 Beliefs to Internal Check Plans Unify SocAcc Add and Events Plans Delete Context Event Applicable Beliefs Plans 3 Messages Messages 8 9 Selected 10 checkMail SM Intended Intention Execute Action Actions SO SI act Means Intention . New New ...

.. friend(bob.. . Introduction AOP EOP OOP Conclusion About AOP Jason Beliefs — Representation Syntax Beliefs are represented by annotated literals of first order logic functor(term1 ..alice)[source(bob)].. 28 / 200 .. annotm ] Example (belief base of agent Tom) red(box1)[source(percept)]. ˜lier(bob)[source(self)]. lier(alice)[source(self). termn )[annot1 .source(bob)]..

Introduction AOP EOP OOP Conclusion About AOP Jason Beliefs — Dynamics I by perception beliefs annotated with source(percept) are automatically updated accordingly to the perception of the agent by intention the plan operators + and .can be used to add and remove beliefs annotated with source(self) (mental notes) +lier(alice). // removes lier(john)[source(self)] 29 / 200 . // adds lier(alice)[source(self)] -lier(john).

lier(alice)).tell.send(tom.. // sent by bob // adds lier(alice)[source(bob)] in Tom’s BB .lier(alice))..send(tom. the content is a new belief annotated with the sender of the message . // sent by bob // removes lier(alice)[source(bob)] from Tom’s BB 30 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason Beliefs — Dynamics II by communication when an agent receives a tell message. .untell.

31 / 200 . but are prefixed by ! (achievement goal) or ? (test goal) Example (Initial goal of agent Tom) !write(book). Introduction AOP EOP OOP Conclusion About AOP Jason Goals — Representation Types of goals Achievement goal: goal to do Test goal: goal to know Syntax Goals have the same syntax as beliefs.

// adds new test goal ?publisher(P)[source(self)] ?publisher(P). . 32 / 200 .. // adds new achievement goal !write(book)[source(self)] !write(book).... Introduction AOP EOP OOP Conclusion About AOP Jason Goals — Dynamics I by intention the plan operators ! and ? can be used to add a new goal annotated with source(self) .

send(tom. the content is a new achievement goal annotated with the sender of the message .write(book)). Introduction AOP EOP OOP Conclusion About AOP Jason Goals — Dynamics II by communication – achievement goal when an agent receives an achieve message. // sent by Bob // adds new goal write(book)[source(bob)] for Tom . ..unachieve.achieve. // sent by Bob // removes goal write(book)[source(bob)] for Tom 33 / 200 .send(tom..write(book)).

askOne. // sent by Bob // adds new goal ?publisher(P)[source(bob)] for Tom // the response of Tom will unify with Answer 34 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason Goals — Dynamics III by communication – test goal when an agent receives an askOne or askAll message.send(tom.Answer).published(P). the content is a new test goal annotated with the sender of the message .

Introduction AOP EOP OOP Conclusion About AOP Jason Triggering Events — Representation Events happen as consequence to changes in the agent’s beliefs or goals An agent reacts to events by executing plans Types of plan triggering events +b (belief addition) -b (belief deletion) +!g (achievement-goal addition) -!g (achievement-goal deletion) +?g (test-goal addition) -?g (test-goal deletion) 35 / 200 .

where: the triggering event denotes the events that the plan is meant to handle the context represent the circumstances in which the plan can be used the body is the course of action to be used to handle the event if the context is believed true at the time a plan is being chosen to handle the event 36 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason Plans — Representation An AgentSpeak plan has the following general structure: triggering event : context ¡.body.

<= (relational) mod (remainder) == (equals) ** (power) \ == (different) 37 / 200 . >= (relational) div (divide – integer) <.(subtraction) not (not) * (multiply) = (unification) / (divide) >. Introduction AOP EOP OOP Conclusion About AOP Jason Plans — Operators for Plan Context Boolean operators Arithmetic operators & (and) + (sum) | (or) .

// new sub-goal !!g2. // internal action X ¿ 10.get(X). -+) Goal operators (!. // update mental note /¿ jia.!g1. // add mental note -b2(T-H).// external action 38 / 200 .now(H) & H ¿= T ¡. // new goal ?b(X). // constraint to carry on close(door). !!) Actions (internal/external) and Constraints Example (plan body) +rain : time to leave(T) & clock. // remove mental note -+b3(T*H). ?. // new test goal +b1(T-H). Introduction AOP EOP OOP Conclusion About AOP Jason Plans — Operators for Plan Body A plan body may contain: Belief operators (+. -.

Introduction AOP EOP OOP Conclusion About AOP Jason Plans — Example +green patch(Rock)[source(percept)] : not battery charge(low) ¡. !examine(Rock).. +!at(Coords) : at(Coords). !at(Coordinates). +!at(Coords) : not at(Coords) & not safe path(Coords) ¡.Coordinates).move towards(Coords)... !at(Coords). 39 / 200 . +!at(Coords) : not at(Coords) & safe path(Coords) ¡.?location(Rock.

Introduction AOP EOP OOP Conclusion About AOP Jason Plans — Dynamics The plans that form the plan library of the agent come from initial plans defined by the programmer plans added dynamically and intentionally by .remove plan plans received from tellHow messages untellHow 40 / 200 .add plan .

Introduction AOP EOP OOP Conclusion About AOP Jason

Strong Negation

Example
+!leave(home)
: ˜raining
¡- open(curtains); ...

+!leave(home)
: not raining & not ˜raining
¡- .send(mum,askOne,raining,Answer,3000); ...

41 / 200

Introduction AOP EOP OOP Conclusion About AOP Jason

Prolog-like Rules in the Belief Base

Example
likely color(Obj,C) :-
colour(Obj,C)[degOfCert(D1)] &
not (colour(Obj, )[degOfCert(D2)] & D2 ¿ D1) &
not ˜colour(C,B).

42 / 200

Introduction AOP EOP OOP Conclusion About AOP Jason

Plan Annotations

Like beliefs, plans can also have annotations, which go in
the plan label
Annotations contain meta-level information for the plan,
which selection functions can take into consideration
The annotations in an intended plan instance can be changed
dynamically (e.g. to change intention priorities)
There are some pre-defined plan annotations, e.g. to force a
breakpoint at that plan or to make the whole plan execute
atomically

Example (an annotated plan)
@myPlan[chance of success(0.3), usual payoff(0.9),
any other property]
+!g(X) : c(t) ¡- a(X).

43 / 200

Introduction AOP EOP OOP Conclusion About AOP Jason

Failure Handling: Contingency Plans

Example (an agent blindly committed to g)
+!g : g.

+!g : ... ¡- ... ?g.

-!g : true ¡- !g.

44 / 200

{ +!G }. . askHow. . source...send(T. line. error(no relevant) means no plan in the agent’s plan library to achieve G { +!G } is the syntax to enclose triggers/plans as terms 45 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason Meta Programming Example (an agent that asks for plans on demand) -!G[error(no relevant)] : teacher(T) ¡.add plan(Plans). !G. in the event of a failure to achieve any goal G due to no relevant plan.. asks a teacher for plans to achieve G and then try G again The failure event is annotated with the error type. Plans).

Introduction AOP EOP OOP Conclusion About AOP Jason Internal Actions Unlike actions.) 46 / 200 . internal actions do not change the environment Code to be executed as part of the agent reasoning cycle AgentSpeak is meant as a high-level language for the agent’s practical reasoning and internal actions can be used for invoking legacy code elegantly Internal actions can be defined by the user in Java libname.action name(. . .

list2 . Introduction AOP EOP OOP Conclusion About AOP Jason Standard Internal Actions Standard (pre-defined) internal actions have an empty library name . waiting/generating events.send(ag.) . etc. 47 / 200 . list/string operations. manipulating the beliefs/annotations/plan library.literal) .drop intention(literal) Many others available for: printing. term2 .print(term1 .union(list1 .intend(literal) . . creating agents. .my name(var ) . list3 ) .perf . . sorting.

go to it when battery is low. go charge it 48 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason Jason × Java I Consider a very simple robot with two goals: when a piece of gold is seen.

doAction(go(a)). lowBattery. Introduction AOP EOP OOP Conclusion About AOP Jason Jason × Java II Example (Java code – go to gold) public class Robot extends Thread { boolean seeGold. public void run() { while (true) { while (! seeGold) { } while (seeGold) { a = selectDirection(). } } } } (how to code the charge battery behaviour?) 49 / 200 .

doAction(go(a)). lowBattery. if (lowBattery) charge(). while (seeGold) { a = selectDirection (). Introduction AOP EOP OOP Conclusion About AOP Jason Jason × Java III Example (Java code – charge battery) public class Robot extends Thread { boolean seeGold. } } } } (note where the tests for low battery have to be done) 50 / 200 . if (lowBattery) charge(). public void run() { while (true) { while (! seeGold) if (lowBattery) charge().

. +!goto(gold) :see(gold) // long term goal ¡. ˆ!charge[state(started)] // goal meta-events ¡. 51 / 200 . ˆ!charge[state(finished)] ¡.suspend(goto(gold)).!select direction(A).resume(goto(gold)). +battery(low) // reactivity ¡.. Introduction AOP EOP OOP Conclusion About AOP Jason Jason × Java IV Example (Jason code) +see(gold) ¡.!goto(gold). go(A).!charge. !goto(gold).

Introduction AOP EOP OOP Conclusion About AOP Jason Jason × Prolog With the Jason extensions. nice separation of theoretical and practical reasoning BDI architecture allows long-term goals (goal-based behaviour) reacting to changes in a dynamic environment handling multiple foci of attention (concurrency) Acting on an environment and a higher-level conception of a distributed system 52 / 200 .

AgentScape) 53 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason Communication Infrastructure Various communication and execution management infrastructures can be used with Jason: Centralised: all agents in the same machine..g.. allows thousands of agents Jade: distributed agents. one thread by agent. KQML . FIPA-ACL Saci: distributed agents. others defined by the user (e. very fast Centralised (pool): all agents in the same machine. fixed number of thread.

g. Introduction AOP EOP OOP Conclusion About AOP Jason Definition of a Simulated Environment There will normally be an environment where the agents are situated The agent architecture needs to be customised to get perceptions and act on such environment We often want a simulated environment (e. to test an MAS application) This is done in Java by extending Jason’s Environment class 54 / 200 .

Introduction AOP EOP OOP Conclusion About AOP Jason Interaction with the Environment Simulator Environment Agent Reasoner Simulator Architecture perceive getPercepts act executeAction change percepts 55 / 200 .

Structure action) { 12 if (action. 18 } } 56 / 200 . 9 } 10 11 public boolean executeAction(String ag.. 15 } 16 . 2 import . 5 public robotEnv() { 6 Literal gp = 7 Literal.equals(. 14 Literal.parseLiteral(”green˙patch(souffle)”). 8 addPercept(gp)..*.....c(3.parseLiteral(”location(souffle.4))”).. 3 public class robotEnv extends Environment { 4 ..)) { 13 addPercept(ag. Introduction AOP EOP OOP Conclusion About AOP Jason Example of an Environment Class 1 import jason. 17 return true..

net. // 10 instances of bob classpath: ”.sourceforge. r2d2 at jason. ˝ 57 / 200 ./lib/graph. Introduction AOP EOP OOP Conclusion About AOP Jason MAS Configuration Language I Simple way of defining a multi-agent system Example (MAS that uses JADE as infrastructure) MAS my˙system – infrastructure: Jade environment: robotEnv agents: c3po.. bob #10.jar”.

.JDBCPersistentBB( ”org. ˝ 58 / 200 .jdbcDriver”. frequency of perception.hsqldb.bb..properties”] agentClass MyAg agentArchClass MyAgArch beliefBaseClass jason. customisations. Introduction AOP EOP OOP Conclusion About AOP Jason MAS Configuration Language II Configuration of event handling. user-defined settings.paramters=”sys. ”jdbc:hsqldb:bookstore”. Example (MAS with customised agent) MAS custom – agents: bob [verbose=2.. etc.

˝ 59 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason MAS Configuration Language III Example (CArtAgO environment) MAS grid˙world – environment: alice.c4jason.CEnv agents: cleanerAg agentArchClass alice.CogAgentArch #3.c4jason.

selectOption. .. buf. Agent architecture customisation: perceive.) 60 / 200 . sendMsg. Belief base customisation: add. selectEvent. brf. ... selectIntetion. act. in data bases. Example available with Jason: persistent belief base (in text files.. remove.. checkMail. Introduction AOP EOP OOP Conclusion About AOP Jason Jason Customisations Agent class customisation: selectMessage. contains. .. ...

Introduction AOP EOP OOP Conclusion About AOP Jason jEdit Plugin 61 / 200 .

Introduction AOP EOP OOP Conclusion About AOP Jason Eclipse Plugin 62 / 200 .

Introduction AOP EOP OOP Conclusion About AOP Jason Mind Inspector 63 / 200 .

Brian Logan. Álvaro Moreira.Wooldridge Planning (Felipe Meneguzzi and Colleagues) Web and Mobile Applications (Alessandro Ricci and Colleagues) Belief Revision Joint work with Natasha Alechina. Mark Jago 64 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason Some Related Projects I Speech-act based communication Joint work with Renata Vieira. Davide Ancona Plan Patterns for Declarative Goals Joint work with M. and Mike Wooldridge Cooperative plan exchange Joint work with Viviana Mascardi.

Dennis.Fisher. M. W.) Joint work with Tricia Shaw Trust reasoning (ForTrust project) Agent verification and model checking Joint project with M.Farwer 65 / 200 .Wooldridge. B. L. Álvaro Moreira JASDL: joint work with Tom Klapiscak Goal-Plan Tree Problem (Thangarajah et al. Introduction AOP EOP OOP Conclusion About AOP Jason Some Related Projects II Ontological Reasoning Joint work with Renata Vieira.Visser.

C.net. related projects 66 / 200 .Okuyama MADeM integration (Francisco Grimaldo Moreno) Normative integration (Felipe Meneguzzi) CArtAgO integration Moise+ integration More on jason.Rocha Costa and F. Organisation and Norms Normative environments Join work with A.sourceforge. Introduction AOP EOP OOP Conclusion About AOP Jason Some Related Projects III Environments.

) Mini-agents (?) Recently done: meta-events To appear soon: annotations for declarative goals. Further work on combining with environments and organisations 67 / 200 . Jadex. Debugging is hard. .. Introduction AOP EOP OOP Conclusion About AOP Jason Some Trends for Jason I Modularity and encapsulation Capabilities (JACK. etc.. improvement in plan failure handling.) Roles (Dastani et al. etc. despite mind inspector.

Introduction AOP EOP OOP Conclusion About AOP Jason Summary AgentSpeak Logic + BDI Agent programming language Jason AgentSpeak interpreter Implements the operational semantics of AgentSpeak Speech-act based communicaiton Highly customisable Useful tools Open source Open issues 68 / 200 .

Wooldrige Programming Multi-Agent Systems in AgentSpeak using Jason John Wiley & Sons.net R. Hübner.H. and M. 69 / 200 . Introduction AOP EOP OOP Conclusion About AOP Jason Further Resources http://jason.F. J.sourceforge. 2007. Bordini.

Environment Oriented Programming — EOP — .

Outline
3 Environment Programming
Why Environment Programming in MAS
Basic Level
Advanced Level
A&A and CArtAgO
Conclusions and Wrap-up

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up

Back to the Notion of Environment in MAS

The notion of environment is intrinsically related to the
notion of agent and multi-agent system
“An agent is a computer system that is situated in some
environment and that is capable of autonomous action in
this environment in order to meet its design
objective” [Wooldridge, 2002]
“An agent is anything that can be viewed as perceiving
its environment through sensors and acting upon the
environment through effectors.
” [Russell and Norvig, 2003]
Including both physical and software environments

72 / 200

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up

Single Agent Perspective

sensors

ack
db

pe
fee PERCEPTION

r
ce
pts
ENVIRONMENT

DECISION
act
ion
s o do
o nt
ti
ac ACTION

effectors / actuators

Perception
process inside agent inside of attaining awareness or
understanding sensory information, creating percepts
perceived form of external stimuli or their absence
Actions
the means to affect, change or inspect the environment
73 / 200

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up

Multi-Agent Perspective

In evidence
overlapping spheres of visibility and influence
..which means: interaction
74 / 200

exogenous ones) programmable environments 75 / 200 . coordination. organisation. security externalisation this implies changing the perspective on the environment environment as a first-class abstraction of the MAS endogenous environments (vs. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Why Environment Programming Basic level to create testbeds for real/external environments to ease the interface/interaction with existing software environments Advanced level to uniformly encapsulate and modularise functionalities of the MAS out of the agents typically related to interaction.

distribution Defining the environment programming model how to program the environment 76 / 200 . topology core aspects to face: concurrency. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Environment Programming: General Issues Defining the interface actions. perceptions data-model Defining the environment computational model & architecture how the environment works structure. behaviour.

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Basic Level Overview MAS MAS ENVIRONMENT actions SIMULATED REAL WORLD mimicking WORLD (PHYSICAL OR COMPUTATIONAL) OR INTERFACE EXTERNAL WORLD (PHYSICAL OR COMPUTATIONAL) OR WRAPPER TO EXISTING Example: percepts JAVA TECHNOLOGY AGENTS PLATFORM 77 / 200 .

. JADEX 78 / 200 .g. GOAL. 2APL. generating percepts Environment API to define the set of actions and program actions computational behaviour which include the generation of percepts typically implemented using as single object/class in OO such as Java method to execute actions fields to store the environment state available in many agent programming languages/frameworks e. Jason. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Basic Level: Features Environment conceptually conceived as a single monolitic block providing actions.

Structure action): boolean +addPercept(String agName. Structure action): boolean percepts 79 / 200 .List<Literal>> +init(String[] args) +stop() getPercepts +getPercepts(String agName): List<Literal> +executeAction(String agName.. 2007a] Flexible Java-based Environment API Environment base class to be specialised executeAction method to specify action semantics addPercept to generate percepts Environment User Agent -globalPercepts: List<Literal> Environment Architecture -agPercepts: Map<String.. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up An Example: Jason [Bordini et al.. executeAction UserEnvironment +init(String[] args) change +executeAction(String agName. Literal p) . Literal p) +removePercept(String agName.

" + r1Loc. Location r1Loc = model.getAgPos(0).setView(view). clearPercepts(). updatePercepts().parseLiteral model. } else if (func." + r2Loc. } updatePercepts(). class MarsView extends GridWorldView { . addPercept(Literal.getAgPos(1).equals("burn")) { if (model. 80 / 200 . private MarsView view.equals("move_towards")) { int x = (int)((NumberTerm)action. } else if (func.y + ")").. Structure action) { Literal pos1 = Literal.parseLiteral("garbage(r2)")).equals("next")) { Literal pos2 = Literal.dropGarb().burnGarb(). if (func. int y = (int)((NumberTerm)action..equals("pick")) { if (model. addPercept(pos1).solve()." + r2Loc.x + ".. } } class MarsModel extends GridWorldModel { .solve().x + ".parseLiteral("garbage(r1)")).hasGarbage(r2Loc)) { model. view = new MarsView(model).getTerm(0)).parseLiteral String func = action..hasGarbage(r1Loc)) { model. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up MARS Environment in Jason public class MarsEnv extends Environment { .getFunctor().. } else if (func.y + ")"). } Location r2Loc = model..moveTowards(x. ("pos(r2. } } } . addPercept(Literal. private MarsModel model. ("pos(r1. } else if (func. model.equals("drop")) { } model. public boolean executeAction(String ag.nextSlot().getTerm(1))." + r1Loc. /* creates the agents perception * based on the MarsModel */ public void init(String[] args) { void updatePercepts() { model = new MarsModel(). model...pickGarb(). addPercept(pos2).y). return true. } else { } return false.

X.pos(P. +!check(slots) : not garbage(r1) <.X. // carry garbage to r2 !take(garb.Y) & pos(r1. /* Initial goal */ drop(S).Y).// remember where to go back ?pos(r1. !!check(slots).desire(carry_to(r2)) <. +!carry_to(R) <.X. 81 / 200 . -+pos(last.. +!at(L) : at(L). Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Jason Agents Playing on Mars // mars robot 1 .pick(garb).Y). +garbage(r1) : not .X. !!check(slots). . +!ensure_pick(S) : garbage(r1) <.?pos(L.R).next(slot). !at(L)....L) : true at(P) :.X.!ensure_pick(S). +!at(L) <. // goes back and continue to check !at(last). +!check(slots). !at(L). !check(slots). <.!carry_to(r2).Y). +!ensure_pick(_). /* Initial beliefs */ +!take(S.Y). /* Plans */ !ensure_pick(S). move_towards(X.Y).

2008b] 2APL BDI-based agent-oriented programming language integrating declarative programming constructs (beliefs. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Another Example: 2APL [Dastani. plans) Java-based Environment API Environment base class implementing actions as methods inside action methods external events can be generated to be perceived by agents as percepts 82 / 200 . goals) and imperative style programming constructs (events.

. Term c){.} public void north(String agent){.. Term x.. public class Env extends apapl..} public Term pickup(String agent){.Environment { public void enter(String agent..} . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Example: Block-world Environment in 2APL package blockworld.... Term y.. } 83 / 200 ..} public Term sensePosition(String agent){.

Y) } RemoveBomb(X. Y ) goto( X. start(0. blue ).Y) . @blockworld( drop( ). RemoveBomb( X. goto( X..Y) } { true } AddBomb(X.Y) } PC-rules: { carry(bomb) } Drop( ) { not carry(bomb)} goto( X.. { bomb(X. Y ) } PG-rules: else if B(B < Y) then clean( blockWorld ) <.. 84 / 200 .B]). Y ) @blockworld( enter( X. L1 ). Drop( ) } .1). goto( 0. if B(A > X) then bomb(3. } PickUp( ). Y. } @blockworld( pickup( ). Beliefs: B(POS = [A. clean( blockWorld ) goto( X. { @blockworld( west().Y){ not bomb(X.3). Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up 2APL Agents in the block-world BeliefUpdates: . L ) } else if B(B > Y) then Goals: { @blockworld( north().true | { not carry(bomb) } PickUp( ) { carry(bomb) } { @blockworld( sensePosition(). L ). L ). clean( blockWorld ) :. POS )...bomb( X. Y ). 0 ). not carry(bomb). { goto( X. L ). goto( X. Y ) <. } else if B(A < X) then Plans: { @blockworld( east(). B(start(X.Y)) .Y) { bomb(X. Y ). Y ) | { @blockworld( south(). L ). . L2 ). Y ) not bomb(X..

. JASON Goal of the initiative design and develop a generic environment interface standard a standard to connect agents to environments . GOAL. commercial applications. environments such as agent testbeds. 2APL. JADEX.. Principles wrapping already existing environments creating new environments by connecting already existing apps creating new environments from scratch Requirements generic reuse 85 / 200 .. 2010] GOAL.. video games. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Environment Interface Stardard – EIS Initiative Recent initiative supported by main APL research groups [Behrens et al.

with effectors and sensors 86 / 200 . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up EIS Meta-Model By means of the Env. Interface agents perform actions and collect percepts actually actions/percepts are issued to controllable entities in environment model represent the agent bodies.

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Environment Interface Features Interface functions attaching. performing actions and retrieving percepts. actions. and notifying observers (software design pattern). registering and unregistering agents. events 87 / 200 . managing the agents-entities-relation. managing the environment Interface Intermediate language to facilitate data-exchange encoding percepts. adding and removing entities. detaching.

Ricci et al. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Advanced Level Overview Vision: environment as a first-class abstraction in MAS [Weyns et al. i. that environment which is an explicit part of the MAS providing an exploitable design & programming abstraction to build MAS applications Outcome distinguishing clearly between the responsibilities of agent and environment separation of concerns improving the engineering practice 88 / 200 .. 2007. 2010b] application or endogenous environments..e.

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Three Support Levels [Weyns et al.. 2007] Basic interface support Abstraction support level Interaction-mediation support level 89 / 200 .

e. the hardware and software and external resources with which the MAS interacts 90 / 200 . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Basic Interface Support The environment enables agents to access the deployment context i.

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Abstraction Support Bridges the conceptual gap between the agent abstraction and low-level details of the deployment context shields low-level details of the deployment context 91 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Interaction-Mediation Support Regulate the access to shared resources Mediate interaction between agents 92 / 200 .

. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Environment Definition Revised Environment definition revised [Weyns et al. 2007] The environment is a first-class abstraction that provides the surrounding conditions for agents to exist and that mediates both the interaction among agents and the access to resources 93 / 200 .

applications [Platon et al... Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Research on Environments for MAS Environments for Multi-Agent Systems research field / E4MAS workshop series [Weyns et al. 2004.. 2005] different themes and issues (see JAAMAS Special Issue [Weyns and Parunak. Weyns and Holvoet. 2007] for a good survey) mechanisms. infrastructures. 2007. Weyns and Holvoet. architectures. 2007] the main perspective is (agent-oriented) software engineering Focus of this tutorial: the role of the environment abstraction in MAS programming environment programming 94 / 200 . 2007. Viroli et al.

but this will be extended to include OOP in next part Environment as first-class runtime abstraction for agents agent perspective to be observed. 2010b] software designers and engineers perspective endogenous environments (vs.. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Environment Programming Environment as first-class programming abstraction [Ricci et al.. used. adapted.. Defining computational and programming frameworks/models also for the environment part 95 / 200 . exogenous one) programming MAS = programming Agents + programming Environment . constructed. ..

as defined in software engineering contexts (Design by Contract) Defining the environment computational model environment structure. behaviour Defining the environment distribution model topology 96 / 200 . percepts. data model contract concept. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Computational Frameworks for Environment Programming: Issues Defining the environment interface actions.

architectures. platforms support for heterogeneous systems 97 / 200 . no agents sharing and calling OO objects effective programming models for controllable and observable computational entities Modularity away from the monolithic and centralised view Orthogonality wrt agent models. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Programming Models for the Environment: Desiderata Abstraction keeping the agent abstraction level e.g.

extension of environment parts support for open systems Reusability reuse of environment parts for different kinds of applications 98 / 200 . replacement. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Programming Models for the Environment: Desiderata Dynamic extensibility dynamic construction.

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Existing Computational Frameworks AGRE / AGREEN / MASQ [Stratulat et al. 2010b] introducing a computational notion of artifact to design and implement agent environments 99 / 200 . 2009] AGRE – integrating the AGR (Agent-Group-Role) organisation model with a notion of environment Environment used to represent both the physical and social part of interaction AGREEN / MASQ – extending AGRE towards a unified representation for physical.. 2000a] GOLEM [Bromuri and Stathis. social and institutional environments Based on MadKit platform [Gutknecht and Ferber.. 2008] Logic-based framework to represent environments for situated cognitive agents composite structure containing the interaction between cognitive agents and objects A&A and CArtAgO [Ricci et al.

A&A and CArtAgO .

CHANNEL artifact RESOURCE artifact TASK SCHEDULER artifact 101 / 200 . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Agents and Artifacts (A&A) Conceptual Model: Background Human Metaphor CLOCK WHITEBOARD BAKERY artifact artifact workspace agents can join dynamically the workspace ARCHIVE artifact COM.

. goal-oriented pro-active entities create and co-use artifacts for supporting their activities besides direct communication Artifacts non-autonomous. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up A&A Basic Concepts [Omicini et al. stateful entities controllable and observable modelling the tools and resources used by agents designed by MAS programmers Workspaces grouping agents & artifacts defining the topology of the computational environment 102 / 200 . function-oriented. 2008] Agents autonomous.

. organized in workspaces Extensibility and openness artifacts can be created and destroyed at runtime by agents Reusability artifacts (types) as reusable entities. 2007b] Abstraction artifacts as first-class resources and tools for agents Modularisation artifacts as modules encapsulating functionalities. for setting up different kinds of environments 103 / 200 . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up A&A Programming Model Features [Ricci et al.

. 2010b] Manual consult has create Workspace Artifact dispose link link Operation use Agent Environment generate update Observable perceive Event Observable perceive Property observe join quit 104 / 200 . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up A&A Meta-Model in More Detail [Ricci et al.

.. LINK INTERFACE 105 / 200 . PROPERTIES USAGE INTERFACE OperationX(Params) ... OPERATIONS OperationY(Params) .. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Artifact Abstract Representation SIGNALS ObsPropName(Args) OBSERVABLE ..

.... clearEvents out postEvent in put setTodo registerForEvs rd get cancelTodo a bounded buffer an agenda an event service a tuple space 106 / 200 . addRecord a flag query a counter . state true wsdl ..... . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up A World of Artifacts n_records 1001 state available count 5 table_names . inc reset switch GetLastTradePrice createTable ..... a Stock Quote Web Service a data-base n_items 0 next_todo check_plant max_items 100 last_todo . ...

an agenda for managing deadlines... console. Social artifacts designed to provide functionalities for structuring and managing the interaction in a MAS coordination artifacts [Omicini et al.g. e..g.. a game-board. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up A Simple Taxonomy Individual or personal artifacts designed to provide functionalities for a single agent use e.. 107 / 200 . etc. a library. 2004].. a Web Service to represent devices enabling I/O with users e.. .g GUI. a blackboard.g.. Boundary artifacts to represent external resources/services e. organisation artifacts. a printer.

2010c] success/failure semantics. execution semantics defining the contract (in the SE acceptation) provided by the environment actions ←→ artifacts’ operation the action repertoire is given by the dynamic set of operations provided by the overall set of artifacts available in the workspace can be changed by creating/disposing artifacts action success/failure semantics is defined by operation semantics percepts ←→ artifacts’ observable properties + signals properties represent percepts about the state of the environment signals represent percepts concerning events signalled by the environment 108 / 200 . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Actions and Percepts in Artifact-Based Environments Explicit semantics defined by the (endogenous) environment [Ricci et al..

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Interaction Model: Use PropName Value PropName Value ... op(parms) .. action op(Params) AGENT Performing an action corresponds to triggering the execution of an operation acting on artifact’s usage interface 109 / 200 ..

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Interaction Model: Operation execution SIGNALS PropName Value OBS PROPERTIES CHANGE Value .. possibly with action feedbacks 110 / 200 ..with success or failure - a process structured in one or multiple transactional steps asynchronous with respect to agent .which can proceed possibly reacting to percepts and executing actions of other plans/activities operation completion causes action completion action completion events with success or failure... action op(Params) AGENT OPERATION EXECUTION action completion ... op(parms) .

PropName(Value).. PropName Value PropName Value Belief base . (or alike) focus AGENT OBSERVER Agents can dynamically select which artifacts to observe predefined focus/stopFocus actions 111 / 200 .. ... Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Interaction Model: Observation PropName(Value).

. as percepts e. PropName(Value)..g.. belief base signals are mapped as percepts related to observable events 112 / 200 . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Interaction Model: Observation PropName(Value). . PropName Value PropName Value Belief base . (or alike) use AGENT OBSERVER By focussing an artifact observable properties are mapped into agent dynamic knowledge about the state of the world..

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Artifact Linkability linkedOp WSP-X WSP-Y Basic mechanism to enable inter-artifact interaction linking artifacts through interfaces (link interfaces) operations triggered by an artifact over an other artifact Useful to design & program distributed environments realised by set of artifacts linked together possibly hosted in different workspaces 113 / 200 .

functionality what functions/services artifacts of that type provide ... .... Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Artifact Manual Agent-readable description of artifact’s... 2008] dynamically choosing which artifacts to use to accomplish their tasks and how to use them strong link with Semantic Web research issues Work in progress defining ontologies and languages for describing the manuals 114 / 200 .operating instructions how to use artifacts of that type Towards advanced use of artifacts by intelligent agents [Piunti et al.

net 115 / 200 . 2007c] Java-based programming model for defining artifacts set of basic API for agent platforms to work within artifact-based environment Distributed and open MAS workspaces distributed on Internet nodes agents can join and work in multiple workspace at a time Role-Based Access Control (RBAC) security model Open-source technology available at http://cartago. 2009a] Computational framework / infrastructure to implement and run artifact-based environment [Ricci et al. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up CArtAgO Common ARtifact infrastructure for AGent Open environment (CArtAgO) [Ricci et al.sourceforge...

2008] by means of bridges creating an action/perception interface and doing data binding Outcome developing open and heterogenous MAS introducing a further perspective on interoperability besides the ACL’s one sharing and working in a common work environment common object-oriented data-model 116 / 200 .. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Integration with Agent Languages and Platforms Integration with existing agent platforms [Ricci et al.

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up JaCa Platform Integration of CArtAgO with Jason language/platform a JaCa program is a dynamic set of Jason agents working together in one or multiple CArtAgO workspaces Mapping actions Jason agent external actions are mapped onto artifacts’ operations percepts artifacts’ observable properties are mapped onto agent beliefs artifacts’ signals are mapped as percepts related to observable events data-model Jason data-model is extended to manage also (Java) objects 117 / 200 .

} } Some API spots Artifact base class @OPERATION annotation to mark artifact?s operations set of primitives to work define/update/. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Example 1: A Simple Counter Artifact class Counter extends Artifact { void init(){ defineObsProp("count".updateValue(p.. inc p.intValue() + 1). count 5 } @OPERATION void inc(){ ObsProperty p = getObsProperty("count"). signal("tick").0). observable properties signal primitive to generate signals 118 / 200 .

// discover the tool // use focus(C).!setupTool(Id).makeArtifact("c0". +?myTool(CounterId): true <. -?myTool(CounterId): true <. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Example 1: User and Observer Agents USER(S) OBSERVER(S) !create_and_use. Working with the shared counter 119 / 200 .V).println(“observed new value: “."Counter".lookupArtifact(“c0”.println(“perceived a tick”).C).CounterId). +!create_and_use : true +!observe : true <. // second use specifying the Id +count(V) inc [artifact_id(Id)]. <. <. ?myTool(CounterId)..wait(10).”c0”)] +!setupTool(C): true <. !observe.?myTool(C). // create the tool +tick [artifact_name(Id. <. inc.

.. console. joinWorkspace.Console operations: println.NodeArtifact core functionalities related to a node operations: createWorkspace. ..... type: cartago. type: cartago. focus. node..TupleSpace operations: out. including security operations: makeArtifact.. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Pre-defined Artifacts Each workspace contains by default a predefined set of artifacts providing core and auxiliary functionalities i.... blackboard. rd. 120 / 200 ...tools.e. a pre-defined repertoire of actions available to agents.WorkspaceArtifact functionalities to manage the workspace. lookupArtifact.tools. type cartago. Among the others workspace. .. type cartago. in. ..

this. } @GUARD boolean itemAvailable(){ return items. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Example 2: Coordination Artifacts – A Bounded Buffer public class BoundedBuffer extends Artifact { private LinkedList<Item> items. with a high-level support for synchronization (await primitive. defineObsProperty("n_items". void init(int nmax){ items = new LinkedList<Item>().0). getObsProperty("n_items"). } } Basic operation features output parameters to represent action feedbacks long-term operations. Item item = items.size() < nmax.removeFirst(). guards) 121 / 200 . } n_items 5 @OPERATION void put(Item obj){ await("bufferNotFull").size() > 0.size()).updateValue(items. items. res.nmax = nmax.add(obj).updateValue(items. put } get @OPERATION void get(OpFeedbackParam<Item> res) { await("itemAvailable").set(item). private int nmax. } @GUARD boolean bufferNotFull(Item obj){ return items.size()). getObsProperty("n_items").

": ".makeArtifact("myBuffer".Buffer). -!setupTools(Buffer) : true <. -?bufferReady : true [10]. <-. <.Buffer). !consumeItem(Item). put(Item). !!produceItems. 122 / 200 . !consumeItems.?bufferReady."BoundedBuffer". <. !produceItems.Item). <. +!consume: true +!produce: true <.!setupTools(Buffer). +!consumeItems: true +!produceItems : true <._). +item_to_produce(N+1). !consume. ?bufferReady.lookupArtifact("myBuffer".?nextItemToProduce(Item).wait(50). Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Example 2: Producers and Consumers PRODUCERS CONSUMERS item_to_produce(0).-item_to_produce(N). !produce.get(Item).lookupArtifact("myBuffer".my_name(Me). <.. !!consumeItems. println(Me. +?bufferReady : true +!setupTools(Buffer) : true <. +!consumeItem(Item) : true +?nextItemToProduce(N) : true <.

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Remarks Process-based operation execution semantics action/operation execution can be long-term action/operation execution can overlap key feature for implementing coordination functionalities Operation with output parameters as action feedbacks 123 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Action Execution & Blocking Behaviour Given the action/operation map. by executing an action the intention/activity is suspended until the corresponding operation has completed or failed action completion events generated by the environment and automatically processed by the agent/environment platform bridge no need of explicit observation and reasoning by agents to know if an action succeeded However the agent execution cycle is not blocked! the agent can continue to process percepts and possibly execute actions of other intentions 124 / 200 .

} } } Internal operations execution of operations triggered by other operations implementing controllable processes 125 / 200 ."Clock". +tick: n_ticks(10) } else { <. } +n_ticks(0). await_time(TICK_TIME). <.Id). @plan1 execInternalOp("work"). focus(Id). void init(){ working = false.").-+n_ticks(N+1). if (!working){ working = true.makeArtifac("myClock". } <. boolean working. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Example 3: Internal Processes – A Clock CLOCK CLOCK USER AGENT public class Clock extends Artifact { !test_clock.").[]. println("clock stopped.stop. } } @plan2 [atomic] +tick: n_ticks(N) @OPERATION void stop(){ working = false. failed("already_working"). @INTERNAL_OPERATION void work(){ while (working){ signal("tick"). start. @OPERATION void start(){ println("clock started. +!test_clock final static long TICK_TIME = 100. println("tick perceived!").

0 ok setValue closed user agent Exploiting artifacts to enable interaction between human users and agents 126 / 200 . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Example 4: Artifacts for User I/O – GUI Artifacts value 16.

linkWindowClosingEventToOp(frame.setValue(V+1).setVisible(true). defineObsProperty("value". } +closed @INTERNAL_OPERATION void ok(ActionEvent ev){ <.kill_agent(Me)...println("Value updated: ". @INTERNAL_OPERATION void updateText(ActionEvent ev){ updateObsProperty("value". frame = new MyFrame().getValue()).parseInt(frame.. focus(Id). <. "closed").} } 127 / 200 . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Example 4: Agent and User Interaction GUI ARTIFACT USER ASSISTANT AGENT public class MySimpleGUI extends GUIArtifact { !test_gui. private MyFrame frame.makeArtifact("gui". } .text. } class MyFrame extends JFrame {. } private int getValue(){ return Integer.Id)."ok"). .getValue()). <. +!test_gui public void setup() { <.okButton. updateObsProperty("value". signal("ok")."MySimpleGUI"."ENTER".getText()). +value(V) linkKeyStrokeToOp(frame. +ok : value(V) frame. linkActionEventToOp(frame. } @OPERATION void setValue(double value){ frame.value).my_name(Me).."updateText")..setText(""+value).V).

.. depending on the agent role ruling agents’ access and use of artifacts of the workspace . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Other Features Other CArtAgO features not discussed in this lecture linkability executing chains of operations across multiple artifacts multiple workspaces agents can join and work in multiple workspaces. concurrently including remote workspaces RBAC security model workspace artifact provides operations to set/change the access control policies of the workspace. See CArtAgO papers and manuals for more information 128 / 200 .

. 2007a] cognitive artifacts for knowledge representation and coordination [Piunti and Ricci.. 129 / 200 . 2010] Including A&A in AOSE methodology [Molesini et al.. 2009] Artifact-based environments for argumentation [Oliva et al.. 2009b]) Cognitive stigmergy based on artifact environments [Ricci et al... 2005] Defining a Semantic (OWL-based) description of artifact environments ( CArtAgO-DL) JaSa project = JASDL + CArtAgO-DL . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up A&A and CArtAgO: Some Research Explorations Designing and implementing artifact-based organisation Infrastructures JaCaMo model and platform (which is the evolution of the ORA4MAS infrastructure [Hübner et al.

sourceforge. 2010a] http://cartagows.. 2011] http://jaca-android. Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Applying CArtAgO and JaCa Using CArtAgO/JaCa for building real-world applications and infrastructures Some examples JaCa-Android implementing mobile computing applications on top of the Android platform using JaCa [Santi et al.net JaCa-WS / CArtAgO-WS building SOA/Web Services applications using JaCa [Ricci et al.net JaCa-Web implementing Web 2.sourceforge..sourceforge.0 applications using JaCa http://jaca-web.net 130 / 200 .

linkability artifacts as first-order entities for agents interaction based on use and observation agents dynamically co-constructing. observable properties / events. evolving. adapting their world CArtAgO computational framework programming and executing artifact-based environments integration with heterogeneous agent platforms JaCa case 131 / 200 . Introduction AOP EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Wrap-up Environment programming environment as a programmable part of the MAS encapsulating and modularising functionalities useful for agents’ work Artifact-based environments artifacts as first-class abstraction to design and program complex software environments usage interface.

Organisation Oriented Programming — OOP — .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Abstractions in Multi-Agent Systems schema mission role ORGAMISATION org LEVEL agent AGENT LEVEL artifact ENDOGENOUS ENVIRONMENT wsp LEVEL EXOGENOUS ENVIRONMENT 133 / 200 .

Outline 4 Organisation Oriented Programming (OOP) Fundamentals Motivations Some OOP approaches Focus on the Moise framework Moise Organisation Modelling Language (OML) Moise Organisation Management Infrastructure (OMI) .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Organisation in MAS – a definition What is an organisation? 135 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Organisation in MAS – a definition What is an organisation? Pattern of agent cooperation with a purpose supra-agent emergent or predefined (by designer or agents) 135 / 200 .

knowledge. Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Introduction: Some definitions Organisations are structured. patterned systems of activity. 2001] Organisations are supra-individual phenomena A decision and communication schema which is applied to a set of actors that together fulfill a set of tasks in order to satisfy goals while guarantying a global coherent state [Malone. memory. 1977] pattern of emergent cooperation 136 / 200 . history. which results into an entity. authority systems. a system. to achieve a purpose An organisation is characterised by: a division of tasks. a distribution of roles. communication systems. and capabilities that are distinct from any single agent [Gasser. culture. or by actors. 1985] pattern of predefined cooperation An arrangement of relationships between components. contribution-retribution systems [Bernoux. 1999] definition by the designer. that has unknown skills at the level of the individuals [Morin.

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Perspective on organisations from EASSS’05 Tutorial (Sichman. Boissier) Agent Centred Agents don’t know Agents know about organisation about organisation Organisation Centred Organisation Specification Local Representation Designer / Observer Organisation Entity Observed Organisation Bottom-up Top-down 137 / 200 .

Interactions. OPERA. AMAS. GAIA. MESSAGE. … MOISE+. SASO Social Reasoning Self-organisations … Coalition formation Contract Net Protocol … Organisation is observed. Implicitly programmed Coalition formation in Agents. STEAM. Organisation is observed. Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Perspective on organisations from EASSS’05 Tutorial (Sichman. Agents don’t know Agents know about organisation about organisation AOSE TAEMS. … Organisation is Organisation-Oriented a design model. AGR MASE. Boissier) Agent Centred Swarms. in Agents. mechanisms programmed Environment. Programming of MAS It is hard-coded in Agents Organisation Centred Organisation Specification Local Representation Designer / Observer Organisation Entity Observed Organisation Bottom-up Top-down 138 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Organisation Oriented Programming (OOP) Programming outside the agents Agent Using organisational concepts Agent To define a cooperative Organisation Specification pattern Agent Program = Specification By changing the Organisation specification. we can Entity change the MAS overall behaviour 139 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Organisation Oriented Programming (OOP) Agent Agent First approach Organisation Specification Agents read the program and follow it Agent Organisation Entity 139 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Organisation Oriented Programming (OOP) Agent Second approach Agent Agents are forced to Organisation follow the program Specification Agent Organisation Entity 139 / 200 .

.. Organisation Entity 139 / 200 . Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Organisation Oriented Programming (OOP) Agent Second approach Agent Agents are forced to Organisation follow the program Specification Agents are rewarded if Agent they follow the program .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Organisation Oriented Programming (OOP) Agent Components Programming language Agent (OML) Organisation Specification Platform (OMI) Integration to agent Agent architectures and environment Organisation Entity 139 / 200 .

TeamCore [Tambe.. 2010]. 140 / 200 . . 2OPL [Dastani et al. 2009]. 2001].. 2002]. 1998]... AGR [Ferber and Gutknecht. 1997]. Islander [Esteva et al. Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Components of OOP: Organisation Modelling Language (OML) Declarative specification of the organisation(s) Specific constraints.g.. Moise+ [Hübner et al. norms and cooperation patterns imposed on the agents Based on an organisational model e. Opera [Dignum and Aldewereld.

ORA4MAS [Hübner et al.e. i. support infrastructure e.g. Regulation mechanisms.e. .. reorganisation infrastructure 141 / 200 .g.. Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Components of OOP: Organisation Management Infrastructure (OMI) Coordination mechanisms. 2006].. 2000b]. governance infrastructure e. MadKit [Gutknecht and Ferber.. . Ameli [Esteva et al. Adaptation mechanisms. i. Karma [Pynadath and Tambe. 2009a]. S-Moise+ [Hübner et al... i. 2003]. 2004].e..

J -Moise+ [Hübner et al. 2009b]..g.g [Piunti et al. 2007]. 1999].. Autonomy based reasoning [Carabelea. regimentation) environment may act on the organisation (e. [Okuyama et al.g. enact rules.. 2008] 142 / 200 . Environment integration mechanisms transform organisation into embodied organisation so that: organisation may act on the environment (e.g. Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Components of OOP: Integration mechanisms Agent integration mechanisms allow agents to be aware of and to deliberate on: entering/exiting the organisation modification of the organisation obedience/violation of norms sanctioning/rewarding other agents e. 2007].. ProsA2 Agent-based reasoning on norms [Ossowski.. count-as rules) e. .

dynamism More and more applications require the integration of human communities and technological communities (ubiquitous and pervasive computing). adaptation 143 / 200 . Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Motivations for OOP: Applications point of view Current applications show an increase in Number of agents Duration and repetitiveness of agent activities Heterogeneity of the agents Number of designers of agents Agent ability to act and decide Openness.. scalability. building connected communities (ICities) in which agents act on behalf of users Trust. security... . flexibility.

to share information. the organisation helps the members of the team to synchronise actions. when a soccer team wants to play match. ‘to bid’ for a product on eBay is an institutional action only possible because eBay defines rules for that very action the bid protocol is a constraint but it also creates the action e. etc 144 / 200 . responsibilities e.g.g. Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Motivations for OOP: Constitutive point of view Organisation helps the agents to cooperate with other agents by defining common cooperation schemes global tasks protocols groups.

when an agent adopts a role. while explicitly addressing the autonomy of the agents within the organisation Normative organisation e. It may decide to obey or disobey these constraints 145 / 200 . Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Motivations for OOP: Normative point of view MAS have two properties which seem contradictory: a global purpose autonomous agents While the autonomy of the agents is essential. it may cause loss in the global coherence of the system and achievement of the global purpose Embedding norms within the organisation of an MAS is a way to constrain the agents’ behaviour towards the global purposes of the organisation. it adopts a set of behavioural constraints that support the global purpose of the organisation.g.

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Motivations for OOP: Agents point of view An organisational specification is required to enable agents to “reason” about the organisation: to decide to enter into/leave from the organisation during execution Organisation is no more closed to change/adapt the current organisation Organisation is no more static to obey/disobey the organisation Organisation is no more a regimentation 146 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Motivations for OOP: Organisation point of view An organisational specification is required to enable the organisation to “reason” about itself and about the agents in order to ensure the achievement of its global purpose: to decide to let agents enter into/leave from the organisation during execution Organisation is no more closed to decide to let agents change/adapt the current organisation Organisation is no more static and blind to govern agents behaviour in the organisation (i.e. regiment) Organisation is no more a regimentation 147 / 200 . monitor. enforce.

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise

Some OOP approaches

AGR/Madkit [Ferber and Gutknecht, 1998]
STEAM/Teamcore [Tambe, 1997]
ISLANDER/AMELI [Esteva et al., 2004]
Opera/Operetta [Dignum and Aldewereld, 2010]
PopOrg [Rocha Costa and Dimuro, 2009]
2OPL [Dastani et al., 2009]
...

148 / 200

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise

Summary

Several models
Several dimensions on modelling organisation
Structural (roles, groups, ...)
Functional (global plans, ....)
Dialogical (scenes, protocols, ...)
Normative (norms)

149 / 200

The Moise Framework

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise

Moise Framework

OML (language)
Tag-based language
(issued from Moise [Hannoun et al., 2000],
Moise+ [Hübner et al., 2002],
MoiseInst [Gâteau et al., 2005])
OMI (infrastructure)
developed as an artifact-based working environment
(ORA4MAS [Hübner et al., 2009a] based on CArtAgO
nodes, refactoring of S-Moise+ [Hübner et al., 2006] and
Synai [Gâteau et al., 2005])
Integrations
Agents and Environment (c4Jason, c4Jadex
[Ricci et al., 2009b])
Environment and Organisation ([Piunti et al., 2009a])
Agents and Organisation (J -Moise+ [Hübner et al., 2007])

151 / 200

links. Obligations Allows agents autonomy! 152 / 200 . plans. Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Moise Modelling Dimensions Environment P E OS Structural OF Functional Specification B Specification Groups. multiplicities Missions. schemas. roles Global goals. inheritance Normative Specification preferences Permissions. Compatibilities.

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Moise OML meta-model (partial view) Agent Goal Structural create Specification delete create delete Normative Social Scheme Specification Group achieve Functional Specification Goal adopt leave commit leave Mission Role Norm composition agent's actions association concept mapping Cardinalities are not represented 153 / 200 .

Groups Functional: Goals. Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Moise OML OML for defining organisation specification and organisation entity Three independent dimensions [Hübner et al.. Schemes Normative: Norms (obligations. Missions. interdictions) Abstract description of the organisation for the designers the agents J -Moise+ [Hübner et al. 2009a] 154 / 200 .. permissions.. 2007] ( well adapted for the reorganisation concerns): Structural: Roles. 2007] the Organisation Management Infrastructure ORA4MAS [Hübner et al.

roles. Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Moise OML Structural Specification Specifies the structure of an MAS along three levels: Individual with Role Social with Link Collective with Group Components: Role: label used to assign rights and constraints on the behavior of agents playing it Link: relation between roles that directly constrains the agents in their interaction with the other agents playing the corresponding roles Group: set of links. compatibility relations used to define a shared context for agents playing roles in it 155 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Structural Specification Example Graphical representation of structural specification of 3-5-2 Joj Team 156 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Moise OML Functional Specification Specifies the expected behaviour of an MAS in terms of goals along two levels: Collective with Scheme Individual with Mission Components: Goals: Achievement goal (default type). when achieved Maintenance goal. Goals of this type are not satisfied at a precise moment but are pursued while the scheme is running. The agents committed to them do not need to declare that they are satisfied Scheme: global goal decomposition tree assigned to a group Any scheme has a root goal that is decomposed into subgoals Missions: set of coherent goals assigned to roles within norms 157 / 200 . Goals of this type should be declared as satisfied by the agents committed to them.

m2. m3 score a goal m1 m3 get the ball shot at the opponent’s goal m1 m2 go towards the opponent field kick the ball to the goal area m2 m2 be placed in the middle field go to the opponent back line m1 m3 kick the ball to (agent committed to m2) be placed in the opponent goal area Key Organizational Entity Scheme Lucio m1 missions goal Cafu m2 success rate sequence choice parallelism Rivaldo m3 Graphical representation of social scheme “side attack” for joj team 158 / 200 . Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Functional Specification Example m1.

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Goal States waiting enabled impossible satisfied waiting initial state enabled goal pre-conditions are satisfied & scheme is well-formed satisfied agents committed to the goal have achieved it impossible the goal is impossible to be satisfied 159 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Moise OML Normative Specification Explicit relation between the functional and structural specifications Permissions and obligations to commit to missions in the context of a role Makes explicit the normative dimension of a role 160 / 200 .

.. go ... Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Norm Specification – example role deontic mission TTF back obliged m1 get the ball.... 30 seconds 161 / 200 . kick .. 3 minute right obliged m2 1 day attacker obliged m3 kick to the goal. .. 1 minute left obliged m2 be placed at .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Organisational Entity structural norrmative functional groups schemas Organisation links norms roles missions specification purpose group schema instances role instances mission Organisation player player Entity agents 162 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Organisation Entity Dynamics 1 Organisation is created (by the agents) instances of groups instances of schemes 2 Agents enter into groups adopting roles 3 Groups become responsible for schemes Agents from the group are then obliged to commit to missions in the scheme 4 Agents commit to missions 5 Agents fulfil mission’s goals 6 Agents leave schemes and groups 7 Schemes and groups instances are destroyed 163 / 200 .

Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Organisation management infrastructure (OMI) Responsibility Managing – coordination. MadKit. AMELI. .g. regulation – the agents’ execution within organisation defined in an organisational specification Agent Agent Agent Agent Organisation OMI Specification (e.) 164 / 200 . S-Moise+ ...

their artifacts) It is suitable for open systems as no specific agent architecture is required All available as open source at http://moise.e.net 165 / 200 . Introduction AOP EOP OOP Conclusion Introduction Motivations OOP Moise Summary – Moise Ensures that the agents follow some of the constraints specified for the organisation Helps the agents to work together The organisation is interpreted at runtime. it is not hardwired in the agents code The agents ‘handle’ the organisation (i.souceforge.

Programming MAS in JaCaMo .

FrameworkORGANISATIONS Language CarTaGO JADE Platform Platform SPEECH COMMUNICATION RESOURCES ACTS LANGUAGES LEGACY INTERACTION SERVICES OBJECTS PROCOLS ENVIRONMENTS INTERACTIONS 167 / 200 . Introduction AOP EOP OOP Conclusion Configuration Putting the Pieces Together INTERNAL BELIEFS GROUPS ROLES EVENTS GOALS SANCTIONS PLANS MISSIONS REWARDS ACTIONS DEONTIC RELATIONS PERCEPTIONS NORMS JASON MOISE ? AGENTS Agent Prog.

g. heterogeneous agents working in the same organisation.g. Introduction AOP EOP OOP Conclusion Configuration Exploiting Orthogonality Treating AOP & EOP & OOP as orthogonal dimensions improving separation of concerns using the best abstraction level and tools to tackle the specific dimensions. extensibility.. heterogeneous agents working in the same environment. the same agent working in different and heterogeneous organisations. reusability 168 / 200 . the same agent working in different heterogeneous environments Outcome from a programming point of view code more clean and understandable improving modularity. avoiding design pitfalls. a blackboard agent) or a collection of autonomous entities (group agent) promoting openness and heterogeneity E.. such as using agents to implement either non-autonomous entities (e.

Introduction AOP EOP OOP Conclusion Configuration JaCaMo A single platform/programming model integrating Jason (AOP) CArtAgO) (EOP) Moise (OOP) A JaCaMo system is composed by a dynamic set of BDI agents programmed in Jason working inside artifact-based environments programmed in CArtAgO organized in terms of Moise organizations 169 / 200 .

Introduction AOP EOP OOP Conclusion Configuration JaCaMo Meta-Model Environment Manual consult External Action Internal Action dimension has create Workspace Artifact dispose Action link Agent join dimension quit Work Environment Operation use Agent Plan update generate Observable Property Observable Event Trigger event Belief perceive Goal create create delete delete Social Scheme Group Goal commit adopt leave leave Organisation Mission Role Norm dimension composition agent's actions Legend association dimension border dependency concept mapping 170 / 200 .

.. .. NOPL engine Platform Java Platform level Operating System 171 / 200 . Conceptual Plan Operations Goal level Agent Artifact Mission WorkspaceArtifact GroupBoard SchemeBoard artifact(SB..ID1) Specification Specification artifact(CONS. Introduction AOP EOP OOP Conclusion Configuration JaCaMo Platform Agent dimension Environment dimension Organisation dimension . .... Jason.. .SchemeBoard.Console.ID2) Groups Schemes . ..... Players Goals Goals Obbligations linkArtifacts adoptRole lookupArtifact leaveRole commintMission (make/dispose)Artifact addScheme leaveMission quitWorkspace removeScheme setGoalAchieved NodeArtifact workspace(WspName.. Console createWorkspace joinWorkspace joinRemoteWorkspace print shutdownNode println JaCaMo workspace Execution level CArtAgO..ID) ... .

sourceforge.net Jason Eclipse Plugin https://docs.sourceforge.sf.7 https://jason.google.net http://jason.sourceforge.net Jason http://jason.net Moise http://moise.sourceforge.com/document/pub?id= 1URDYMtFP64rHnlb7GcnKyUGbaypNcZmteWupWD5p6sM Other Relevant URLs and Projects JaCaMo http://jacamo. Introduction AOP EOP OOP Conclusion Configuration Downloads JaCaMo within the eclipse platform Jason ≥ 1.sourceforge.net http://jaca-android.net http://jaca-web.net CArtAgO http://cartago.net/jBook 172 / 200 .3.sourceforge.sourceforge.

Introduction AOP EOP OOP Conclusion Configuration JaCaMo Wizard 173 / 200 .

Introduction AOP EOP OOP Conclusion Configuration Configuring the Infrastructure 174 / 200 .

Introduction AOP EOP OOP Conclusion Configuration Code organization 175 / 200 .

Introduction AOP EOP OOP Conclusion Configuration Running an JaCaMo Application 176 / 200 .

Introduction AOP EOP OOP Conclusion Configuration Application in execution 177 / 200 .

volume 4327 of Lecture Notes in Computer Science. 2006. and Winikoff. DALT 2007. Revised Selected and Invited Papers. van Riemsdijk. volume 4897 of Lecture Notes in Computer Science. USA.. Baldoni. M.. Son. J. 7th International Workshop. editors (2006). Selected and Revised Papers. van Riemsdijk.. B. M. Introduction AOP EOP OOP Conclusion Configuration Bibliography I Baldoni.. U. Japan. editors (2010). M. Selected. A. and Lloyd. Declarative Agent Languages and Technologies V. J. July 25... May 8. Bentahar. DALT 2006. 178 / 200 . 4th International Workshop. Declarative Agent Languages and Technologies VII. Revised Selected and Invited Papers. Hakodate. Baldoni. Declarative Agent Languages and Technologies IV. Springer. The Netherlands. Declarative Agent Languages and Technologies III. M. May 14. volume 3904 of Lecture Notes in Computer Science. M. U... and Endriss. 5th International Workshop.. editors (2008). DALT 2009. Utrecht. HI. May 11. Springer. DALT 2005. Budapest. 2009. Revised and Invited Papers. C. Omicini. Third International Workshop. M.. Springer. M. editors (2006). and Torroni.. Hungary.. Endriss. 2005. T. Baldoni. B. Honolulu. P.. volume 5948 of Lecture Notes in Computer Science. 2007. Springer.

2008.. Bordini. Programming Multi-Agent Systems in AgentSpeak Using Jason.. Dix.. L.. J.. editors (2009). B.. M. Hbner. M. Seuil. La sociologie des organisations.. T. J.. Bordini. Behrens. Wiley-Interscience. A. R. M. C. Dastani. An interface for agent-environment interaction. Bernoux. 6th International Workshop. Springer. van Riemsdijk. (2010). Son. DALT 2008. P. Portugal. J.. M... May 12. K. Estoril. M.. In In Proceedings of International Workshop on Programming Multi-Agent Systems (ProMAS-8). 3ème edition. 179 / 200 . volume 5397 of Lecture Notes in Computer Science. Hübner. and Wooldridge. (2007a). Revised Selected and Invited Papers. Braubach. Hindriks. (1985). Introduction AOP EOP OOP Conclusion Configuration Bibliography II Baldoni.. and Pokahr. R. Declarative Agent Languages and Technologies VI. T. and Winikoff.

. Platforms and Applications. Dastani. A. Dastani. Informatica (Slovenia). A. M. Leite. NY.. R. Dix. A.. Second International Workshop ProMAS 2004. (2006a).. J.. M. P.. E. M. J. July 20. and Fallah-Seghrouchni. and Fallah-Seghrouchni... Fallah-Seghrouchni. J. and Simulated Organizations. A. volume 15 of Multiagent Systems. 30(1):33–44. J. Dastani. A. Springer. and Ricci. 180 / 200 . Braubach.. Bordini. USA. R. A survey of programming languages and platforms for multi-agent systems. Pokahr.. G. Artificial Societies. Multi-Agent Programming: Languages. Bordini. New York. Programming Multi-Agent Systems. Introduction AOP EOP OOP Conclusion Configuration Bibliography III Bordini. volume 3346 of Lecture Notes in Computer Science.. J.. editors (2005a). H. M. 2004 Selected Revised and Invited Papers. Gómez-Sanz. E. editors (2005b)... E. Dix.. H. O’Hare.. Springer. R. H. L.

volume 4411 of Lecture Notes in Computer Science.. J... J. editors (2006b). Revised and Invited Papers. John Wiley & Sons. 2005.. R. M. The Netherlands. R.. H. H. and Wooldridge. Dix. A. and Fallah-Seghrouchni. and Fallah-Seghrouchni.. Dix. Dastani. Springer. editors (2009). 181 / 200 . Dastani.. Springer. F. editors (2007b). R. Dix. H. R. ProMAS 2006. July 26. A. Bordini. H. Hakodate. Bordini. E. Programming Multi-Agent Systems. Springer.. and Fallah-Seghrouchni. ProMAS 2005. Revised and Invited Papers. Hübner. M. J..... Tools and Applications. May 9. A. M. Dastani. Introduction AOP EOP OOP Conclusion Configuration Bibliography IV Bordini. Programming Multi-Agent Systems. (2007c). Utrecht. E. M.. Wiley Series in Agent Technology. 2006. 4th International Workshop. Japan. J. Multi-Agent Programming: Languages. E. Third International Workshop.. Bordini. Programming Multi-Agent Systems in AgentSpeak Using Jason. volume 3862 of Lecture Notes in Computer Science.

pages 115–134. In Weyns. K.. Autonomous Agent and Multi-Agent Systems. 2APL: a practical agent programming language. Dastani. 16(3):214–248.. 182 / 200 . editors. M. in french. Autonomous Agents and Multi-Agent Systems. Reasoning about autonomy in open multi-agent systems . volume 5049 of LNCS. (2008). Carabelea. M. ENS Mines Saint-Etienne. Y. Brueckner. 2apl: a practical agent programming language. and Demazeau. (2007). S.an approach based on the social power theory. C. (2008a). 16(3):214–248. Situating Cognitive Agents in GOLEM.. S. D. (2008b). Springer Berlin / Heidelberg. Dastani. and Stathis. Engineering Environment-Mediated Multi-Agent Systems. Introduction AOP EOP OOP Conclusion Configuration Bibliography V Bromuri.

Durham. J. Springer. Methodologies and Development Tools for Multi-Agent Systems. editors (2004). Second International Workshop. M. 183 / 200 . Springer. and Torroni. Fallah-Seghrouchni. First International Workshop.. 2009. A. September 7-9. M. editors (2010). P. Languages. Selected Revised and Invited Papers.. J.. A. Melbourne. Italy. Fallah-Seghrouchni. volume 6039 of Lecture Notes in Computer Science. A.. Torino. E.. and Fallah-Seghrouchni.. volume 5118 of Lecture Notes in Computer Science. LADS 2009. 2007. J. Dastani. PROMAS 2003.. M. July 15. P. Leite. editors (2008a). Programming Multi-Agent Systems. 2003. Leite. Revised Selected Papers. E. Methodologies. Australia. September 4-6. Introduction AOP EOP OOP Conclusion Configuration Bibliography VI Dastani. UK. Revised Selected Papers. Dix. volume 3067 of Lecture Notes in Computer Science... Languages. Dastani. and Development Tools for Multi-Agent Systems. First International Workshop. E. LADS 2007. Springer. and Torroni...

Introduction AOP EOP OOP Conclusion Configuration

Bibliography VII

Dastani, M., Fallah-Seghrouchni, A. E., Ricci, A., and Winikoff, M., editors
(2008b).
Programming Multi-Agent Systems, 5th International Workshop, ProMAS
2007, Honolulu, HI, USA, May 15, 2007, Revised and Invited Papers, volume
4908 of Lecture Notes in Computer Science. Springer.
Dastani, M., Grossi, D., Meyer, J.-J., and Tinnemeier, N. (2009).
Normative multi-agent programs and their logics.
In Meyer, J.-J. and Broersen, J., editors, Knowledge Representation for Agents
and Multi-Agent Systems, volume 5605 of Lecture Notes in Computer Science,
pages 16–31. Springer Berlin / Heidelberg.

Dignum, V. and Aldewereld, H. (2010).
Operetta: Organization-oriented development environment.
In Proceedings of LADS @ MALLOW 2010, pages 14–20.
Esteva, M., Rodriguez-Aguiar, J. A., Sierra, C., Garcia, P., and Arcos, J. L.
(2001).
On the formal specification of electronic institutions.
In Dignum, F. and Sierra, C., editors, Proceedings of the Agent-mediated
Electronic Commerce, LNAI 1191, pages 126–147, Berlin. Springer.

184 / 200

Introduction AOP EOP OOP Conclusion Configuration

Bibliography VIII

Esteva, M., Rodrı́guez-Aguilar, J. A., Rosell, B., and L., J. (2004).
AMELI: An agent-based middleware for electronic institutions.
In Jennings, N. R., Sierra, C., Sonenberg, L., and Tambe, M., editors, Proc. of
the 3rd Int. Joint Conf. on Autonomous Agents and Multi-Agent Systems
(AAMAS’04), pages 236–243, New York, USA. ACM.

Ferber, J. and Gutknecht, O. (1998).
A meta-model for the analysis and design of organizations in multi-agents
systems.
In Demazeau, Y., editor, Proceedings of the 3rd International Conference on
Multi-Agent Systems (ICMAS’98), pages 128–135. IEEE Press.

Fisher, M. (2005).
Metatem: The story so far.
In [Bordini et al., 2006b], pages 3–22.

Fisher, M., Bordini, R. H., Hirsch, B., and Torroni, P. (2007).
Computational logics and agents: A road map of current technologies and
future trends.
Computational Intelligence, 23(1):61–91.

185 / 200

Introduction AOP EOP OOP Conclusion Configuration

Bibliography IX

Gasser, L. (2001).
Organizations in multi-agent systems.
In Pre-Proceeding of the 10th European Worshop on Modeling Autonomous
Agents in a Multi-Agent World (MAAMAW’2001), Annecy.

Gâteau, B., Boissier, O., Khadraoui, D., and Dubois, E. (2005).
Moiseinst: An organizational model for specifying rights and duties of
autonomous agents.
In Third European Workshop on Multi-Agent Systems (EUMAS 2005), pages
484–485, Brussels Belgium.
Giacomo, G. D., Lespérance, Y., and Levesque, H. J. (2000).
Congolog, a concurrent programming language based on the situation calculus.
Artif. Intell., 121(1-2):109–169.

Gutknecht, O. and Ferber, J. (2000a).
The MADKIT agent platform architecture.
In Agents Workshop on Infrastructure for Multi-Agent Systems, pages 48–55.
Gutknecht, O. and Ferber, J. (2000b).
The MadKit agent platform architecture.
In Agents Workshop on Infrastructure for Multi-Agent Systems, pages 48–55.

186 / 200

Introduction AOP EOP OOP Conclusion Configuration

Bibliography X

Hannoun, M., Boissier, O., Sichman, J. S., and Sayettat, C. (2000).
Moise: An organizational model for multi-agent systems.
In Monard, M. C. and Sichman, J. S., editors, Proceedings of the International
Joint Conference, 7th Ibero-American Conference on AI, 15th Brazilian
Symposium on AI (IBERAMIA/SBIA’2000), Atibaia, SP, Brazil, November
2000, LNAI 1952, pages 152–161, Berlin. Springer.
Hindriks, K. V. (2009).
Programming rational agents in GOAL.
In [Bordini et al., 2009], pages 119–157.

Hindriks, K. V., de Boer, F. S., van der Hoek, W., and Meyer, J.-J. C. (1997).
Formal semantics for an abstract agent programming language.
In Singh, M. P., Rao, A. S., and Wooldridge, M., editors, ATAL, volume 1365
of Lecture Notes in Computer Science, pages 215–229. Springer.
Hindriks, K. V., Pokahr, A., and Sardiña, S., editors (2009).
Programming Multi-Agent Systems, 6th International Workshop, ProMAS
2008, Estoril, Portugal, May 13, 2008. Revised Invited and Selected Papers,
volume 5442 of Lecture Notes in Computer Science. Springer.

187 / 200

. Springer. Sichman. F. Journal of Autonomous Agents and Multi-Agent Systems. Hübner. J. and Boissier.. O. (2009a). R. G. A model for the structural.1007/s10458-009-9084-y. S. F.. O... A. Boissier. and Ramalho. Kitio. pages 118–128. Autonomous Agents and Multi-Agent Systems. Introduction AOP EOP OOP Conclusion Configuration Bibliography XI Hübner. volume 2507 of LNAI. J. and Ricci. G.. R. Boissier.. Hübner. Berlin.doi. and Ricci. O. F. In Bittencourt.. functional.org/10. DOI-URL: http://dx. A. L. Kitio. and deontic specification of organizations in multiagent systems. J.. Instrumenting multi-agent organisations with organisational artifacts and agents: “Giving the organisational power back to the agents”. (2002). Proceedings of the 16th Brazilian Symposium on Artificial Intelligence (SBIA’02). editors. 188 / 200 . (2009b). Instrumenting Multi-Agent Organisations with Organisational Artifacts and Agents. J.

Agent-Oriented Software Engineering. J. Revised Selected and Invited Papers.. NY... E. volume 3913 of LNCS. editors (2005). Revised Selected Papers. O. Springer. P. O. Declarative Agent Languages and Technologies II. First International Workshop. P. July 15. Springer. O. J. S. J. editors (2004).. S. Organizations. J. and Sichman. J. A.. and Yolum.. J. Torroni. Omicini. New York. and Boissier. Hübner.. Dignum... July 19. USA. Springer. (2007). V. Coordination. 1(3/4):370–395. editors. A.. Melbourne. P. In Boissier. pages 64–78.. Institutions. Sichman. Sichman. volume 3476 of Lecture Notes in Computer Science. 2003.. S-MOISE+: A middleware for developing organised multi-agent systems. J. F. Introduction AOP EOP OOP Conclusion Configuration Bibliography XII Hübner. Leite. DALT 2003. Leite. Matson.. volume 2990 of Lecture Notes in Computer Science. 2004. (2006). and Norms in Multi-Agent Systems.. A. Second International Workshop. Australia. A. Sterling. Developing Organised Multi-Agent Systems Using the MOISE+ Model: Programming Issues at the System and Agent Levels. L.. and Torroni.. S. Declarative Agent Languages and Technologies. F. Omicini. and Boissier. DALT 2004. 189 / 200 .

A. (1977). O. In Dikenelli. (1999). 45(3):425–443. Y. A. A. 2009]. Bordini. and da Rocha Costa. Denti... R. M. pages 29–46. W. Morin. 6th International Workshop “Engineering Societies in the Agents World” (ESAW’05). Ege University. Management Science. and Ricci. C. A.. editors. H. A. Molesini. Points Seuil. E. (2008). Turkey.-P. E.. Kuşadası. In [Baldoni et al. F. La méthode (1) : la nature de la nature. Introduction AOP EOP OOP Conclusion Configuration Bibliography XIII Malone. Okuyama. Aydın.. Omicini... T... and Ricci. SODA: A roadmap to artefacts. (2005). 190 / 200 . pages 239–252. Tools for inventing organizations: Toward a handbook of organizational process. Gleizes. A distributed normative infrastructure for situated multi-agent organisations.

Omicini. A. on Autonomous Agents and Multi-Agent Systems (AAMAS’04). Springer. Introduction AOP EOP OOP Conclusion Configuration Bibliography XIV Oliva. A. Omicini. A. volume 1. Autonomous Agents and Multi-Agent Systems. M. 4(S10):90–117.. M. and Viroli. 191 / 200 . volume 1535 of LNAI. Ossowski. P. C.. New York. Joint Conf. of the 3rd Int.. Artifacts in the A&A meta-model for multi-agent systems. A.. McBurney. Viroli.. (2010). In Proc. USA. (2008). A. Special Issue on Negotiation and Argumentation in Artificial Intelligence. Ricci. (1999)... ACM. M. Ricci. Argumentation and artifacts for negotiation support. Coordination artifacts: Environment-based coordination for intelligent agents. Castelfranchi. International Journal of Artificial Intelligence. S. E. L. pages 286–293. and Viroli. 17(3):432–456. and Tummolini... (2004). Co-ordination in Artificial Agent Societies: Social Structures and Its Implications for Autonomous Problem-Solving Agents. Omicini.

. Embodied organisations in mas environments. and Hübner. W. O. In IEEE/WIC/ACM International Conference on Web Intelligence and Intelligent Agent Technology (WI-IAT 2009). Piunti. O. J. Petta. M. Italy. September 9-11. (2009). Milan.. A. Cognitive artifacts for intelligent agents in mas: Exploiting relevant information residing in environments.. M. and Ricci. volume 5774 of LNCS. 192 / 200 . Springer. Piunti. Springer... A. Ricci. and Hubner. Introduction AOP EOP OOP Conclusion Configuration Bibliography XV Piunti. In Braubach. Germany.. Ricci. (2009b). Boissier. editors. volume 5605 of LNAI. Hamburg.. and Pokahr.. F. P... L. In Knowledge Representation for Agents and Multi-Agent Systems (KRAMAS 2008). A. van der Hoek. Boissier. pages 115–127. Embodying organisations in multi-agent work environments. (2009a). A. Proceedings of 7th German conference on Multi-Agent System Technologies (MATES 09). J. M.

. Pynadath. In Proc. D. An automated teamwork infrastructure for heterogeneous software agents and humans. A.. Braubach. (2008). Autonomous Agents and Multi-Agent Systems. M. 193 / 200 . A.. pages 149–174... V. and Tambe. and Lamersdorf. Autonomous Agents and Multi-Agent Systems. Conf. volume 2. 2005a]. Goal-directed interactions in artifact-based mas: Jadex agents playing in CARTAGO environments. N. (2007). Mamei... M. In [Bordini et al. 7(1-2):71–100. S. IEEE Computer Society. E. Pokahr. L. L. 14(1):31–47. Honiden. and Pokahr. Mechanisms for environments in multi-agent systems: Survey and opportunities. Braubach. and Parunak. (2005). of the 2008 IEEE/WIC/ACM Int.. A. on Web Intelligence and Intelligent Agent Technology (IAT’08). W.. Ricci. Introduction AOP EOP OOP Conclusion Configuration Bibliography XVI Piunti. Platon. M. H. Jadex: A bdi reasoning engine. (2003). Sabouret. V..

Parunak. Denti. J. Ricci. Environments for MultiAgent Systems III. In de Velde. In Weyns. V. 194 / 200 . volume 4389 of LNAI. W. Springer.. M. Multiagent and Grid Systems International Journal (MAGS).. M.. volume 1038 of Lecture Notes in Computer Science. A platform for developing SOA/WS applications as open and heterogeneous multi-agent systems. and Perram. Cognitive stigmergy: Towards a framework based on agents and artifacts.. Ricci. F. Omicini. Introduction AOP EOP OOP Conclusion Configuration Bibliography XVII Rao. Web Services and Ontologies: Integrated Methodologies”. S.. pages 124–140.. W. A.. L. H. E.. Agentspeak(l): Bdi agents speak out in a logical computable language. pages 42–55.. (2007a). A.. and Oliva. Gardelli. A. To Appear. editors. A. Springer. V. D. MAAMAW. D. (2010a). and Michel. editors. E. (1996). and Piunti. Viroli. Special Issue about “Agents.

. (2010b).. Acay.. and Dastani.. M.. Ricci. Ricci.. Multi-Agent Programming: Languages. M. A. Environment programming in CArtAgO.. A. M. Vol. J. J. M.. and El Fallah-Seghrouchni.. Piunti. Hübner.. (2008). A. M. M. M. Springer Berlin / Heidelberg. In Bordini. Bordini. D. L.. and Omicini. and Viroli. 2. A. A. R. 195 / 200 . In Proceedings of 7th International Conference on Agents and Multi Agents Systems (AAMAS08). Autonomous Agents and Multi-Agent Systems. Dix.. Piunti. Dastani. (2009a). Viroli. R. Piunti. Environment programming in multi-agent systems – an artifact-based perspective. pages 259–288. Platforms and Applications. Published Online with ISSN 1573-7454 (will appear with ISSN 1387-2532). H. Introduction AOP EOP OOP Conclusion Configuration Bibliography XVIII Ricci. editors.. Integrating artifact-based environments with heterogeneous agent-programming platforms..

.. A. Viroli. A. In Dastani.. Action and perception in multi-agent programming languages: From exogenous to endogenous environments. (2010c)..Vol. pages 91–109.2.. A. Programming Multi-Agent Systems. and Omicini. and Winikoff.. and Piunti. In In Proceedings of International Workshop on Programming Multi-Agent Systems (ProMAS-8).Platforms and Applications. 196 / 200 . A. Piunti. A. El Fallah Seghrouchni. (2009b). editors... Ricci. M. Viroli. Springer. (2007b). Ricci. A. Environment programming in CArtAgO. M. and Omicini.. Ricci.. A. Introduction AOP EOP OOP Conclusion Configuration Bibliography XIX Ricci.. M. Springer Berlin / Heidelberg. volume 4908 of LNAI. The A&A programming model & technology for developing agent environments in MAS. A. Santi. M. In Multi-Agent Programming: Languages. M. M.

P.. Rocha Costa. (2011). Springer Verlag.. In Dignum.). M. Viroli... Guidi. Hakodate. 8 May 2006. Introduction AOP EOP OOP Conclusion Configuration Bibliography XX Ricci. and Michel. Russell. Prentice Hall. editors. V. G. and Norvig. and Dimuro. H. (2007c). C. Springer. d. volume 4389 of LNAI. volume 6822 of LNAI. Artificial Intelligence. Selected Revised and Invited Papers. 3rd International Workshop (E4MAS 2006). A minimal dynamical organization model. CArtAgO: A framework for prototyping artifact-based environments in MAS. A. (2009). D.. IGI Global. pages 67–86. In Languages. M. V. A Modern Approach (2nd ed. Santi. and Ricci. pages 419–445. and Omicini. Japan. S.. editor.. Methodologies and Development Tools for Multi-agent systems. 197 / 200 . F. Environments for MultiAgent Systems III. A. Parunak. Multi-Agent Systems: Semantics and Dynamics of Organizational Models. In Weyns. A. A. chapter XVII. D. (2003). A. Jaca-android: An agent-based platform for building smart mobile applications..

7:83–124. J. 14(1):49–60. T. Tambe. A. Towards flexible teamwork. D. and Tranier. and Holvoet. 198 / 200 . (2004). Fundamenta Informaticae. T. A formal model for situated multi-agent systems.. M. Introduction AOP EOP OOP Conclusion Configuration Bibliography XXI Shoham.. Y. J.. (1997). Schelfthout. Stratulat. (1993). Weyns. and Zambonelli. Journal of Artificial Intelligence Reseearch. K. Agent-oriented programming. In AAMAS (2). 60(1):51–92. T. Autonomous Agents and Multi-Agent Systems. Ricci. (2007)... Artif. Ferber. F. Viroli. MASQ: towards an integral approach to interaction. pages 813–820. Intell.. Holvoet. M. (2009).. Infrastructures for the environment of multiagent systems. 63(2-3):125–158.

Holvoet. H. J. Environment as a first-class abstraction in multi-agent systems. Jack intelligent agents: An industrial strength platform. Special Issue on Environments for Multi-Agent Systems. T. H. volume 4389 of LNCS.... 14(1):5–30. and Odell. T. 199 / 200 . pages 175–193. H. Weyns. D. Environments for multiagent systems: State-of-the-art and research challenges.. Springer Berlin / Heidelberg. In Environments for Multiagent Systems III. Omicini. Springer Netherlands. Environment for Multi-Agent Systems. V. D. In [Bordini et al. (2007). Introduction AOP EOP OOP Conclusion Configuration Bibliography XXII Weyns. (2007). volume 14 (1) of Autonomous Agents and Multi-Agent Systems. F. Springer Berlin / Heidelberg. and Parunak. pages 1–40. Weyns. M. D. D. volume 3374. Holvoet. editors... J. and Holvoet. (2005). and Ferber. pages 1–47.. Parunak. J. J.. Michel. Parunak.. D. Winikoff. A... 2005a].. V. F. D. V. Autonomous Agents and Multi-Agent Systems. (2005). In Weyns.. D. A reference architecture for situated multiagent systems. D. T. Weyns. editors (2007). and Ferber. Michel.

Introduction AOP EOP OOP Conclusion Configuration Bibliography XXIII Wooldridge. 200 / 200 . (2002). Ltd. John Wiley & Sons. An Introduction to Multi-Agent Systems. M.