INTERDEPENDENT ARTIFICIAL INSTITUTIONS IN AGENT ENVIRONMENTS

Abstract

In this paper we present a new approach to model artificial institutions (AIs) that are situated in agent environments where heterogeneous agents reside. An AI is seen here as an entity that can evolve over time, whose rules, in terms of powers, permissions, and obligations, are perceivable as first-class entities by the agents belonging to the institution. We use a Multi-Agent Normative EnvironmenTs (MANET) meta-model for the specification of AIs that are situated in first-class agent environments. We present the concepts of MANET in a way that makes them re-usable in different application domains, and we extend our presentation with the study of AIs interdependences for the specification of the institutional part of a first-class environment. As a consequence, our framework presents institutions as first-class abstractions that can be inspected, manipulated and modified, created and destroyed by the agents populating the agent environment where the institution resides. We use an e-Energy marketplace scenario to illustrate the properties of our model.

INTRODUCTION

In the modern computer science domain, an increasing number of applications can be characterized as complex open multi-agent systems (MASs) (Gruber 2007). In these types of systems, heterogeneous agents representing different stakeholders can join, leave, and use the MAS infrastructure at any time in order to achieve their goals (Pitt, Mamdani, and Charlton 2001). Due to the nature of open MASs, many researchers have proposed institutional approaches in order to study the dynamics of these systems (Ägotnes, van der Hoek, and Wooldridge 2007, Esteva et al. 2001). These solutions are based on the idea of applying institutional norms to the MAS in order to regulate the behavior of different agents. The main structure in which the system designer can impose rules to shape the agent interaction is the institution (Esteva et al. 2001).

In our previous work (Tampitsikas, Bromuri, and Schumacher 2011) we presented Multi-Agent Normative EnvironmenTs (MANET), a first effort toward a meta-model to specify the institutional part of the agent environment. The main idea behind MANET is that the agent environment can be organized as a set of fundamental first-class elements (Strachey 2000), called spaces, which are the main mediators of agents' institutional interactions. Spaces contain objects, which represent all the elements that belong to an institution (e.g., norms, institutional objects, etc.; Esteva et al. 2008; Fornara and Colombetti 2009) at a certain time. These fundamental entities can be perceived by the agents who can then modify their state by utilizing a complex event system.

In this paper we present the concepts of MANET in a way that makes them re-usable in different application domains, and we extend our presentation with the study of AIs' interdependences for the specification of the institutional part of a first-class environment. In particular, we propose a model for the concrete realization of the various components of artificial institutions (AIs) presented in the OCeAn (Ontology, CommitmEnts, Authorizations, Norms) meta-model (Fornara and Colombetti 2009) by means of institutional spaces and objects. That is, we describe all AIs' fundamental components as first-class citizens (Strachey 2000) and we provide a mechanism for automatically creating, deleting, and modifying their states. We also specify norms as first-class objects, meaning that the agents can observe the norms and reason about them at runtime. Although perception of norms implies that the agents can interpret them, for the purposes of this paper we focus only on the institutional interactions of the agents and not on how an agent is reasoning about the norms.

AIs can be dynamically created by means of institutional spaces and deleted at runtime based on: (1) the interaction among agents and (2) the agent obligations that are activated and fulfilled during the runtime of the MAS. The idea of dynamic creation of AIs is leading to complex topologies and hierarchies of multiple interdependent institutions. Multiple institutions' interrelations and their influence on the behavior of the agents is a relevant open research issue (Cliffe, DeVos, and Padget 2007; Colombetti, Fornara, and Verdicchio 2002). A second important contribution of this paper is the definition of an approach for managing institutional spaces' interdependencies. In particular, we propose an approach based on the first-class concepts of space and object for tackling two basic AIs interdependency questions: (1) How is the behavior of an agent affected when it is simultaneously participating in more than one institutional space that contains conflicting norms? (2) How is it possible to monitor and mediate(if applicable) the behavior of an agent participating in more than one institutional space?

We illustrate the properties of our approach by means of an e-Energy marketplace scenario. In an e-Energy marketplace, agents representing different types of energy producers try to sell the energy to potential consumers. The balance between energy demand and energy production is achieved through agents representing retailers who are trying to build a portfolio of energy providers and energy consumers using multiple auction systems (Block et al. 2009). The multiple auction system of the e-Energy marketplace is considered here as a multiple institutions system, in which complex topologies and interdependencies of AIs are present.

The remainder of this paper is structured as follows: the section Artificial Institutions Situated in First-Class Agent Environments is a description of the main properties of agent environments that we have to take into consideration in order to define our AI meta-model; the section A Meta-Model for First-Class Artificial Institutions presents our meta-model of first-class Artificial Institutions; the Modeling Energy Market in MANET section shows how we apply our model within an e-Energy Market scenario; the Execution and Evaluation section shows the implementation and evaluation of our model; the Related Work section compares our work with related approaches; finally, the Conclusion and Future Work section concludes this paper and suggests directions for some possible future work.

ARTIFICIAL INSTITUTIONS SITUATED IN FIRST-CLASS AGENT ENVIRONMENTS

The agent environment can be used as a first-class abstraction that mediates the interaction between agents in a MAS. First-class abstraction means that the environment is an independent component that has its own responsibilities irrelevant to the goals of the agents. According to Weyns (Weyns et al. 2009) the agent environment coordinates and constrains the actions that the agents can perform at a given time. At the same time, the agent environment provides to the agents those interfaces that are necessary in order to perceive the environment and the other agents situated in it.

Artificial institutions (Fornara and Colombetti 2009), as a fundamental approach to normative systems, have many properties of agent environments:

	– They mediate the interactions taking place between the agents (Searle 1995).
	– They contain a description in terms of a declarative ontology that defines the concepts that can be expressed in the institution.
	– They are complex structures that evolve over time.

Despite these similarities, AIs suffer from a number of drawbacks that can be eliminated when they are situated in agent environments. Although AIs provide a level of abstraction in terms of institutional rules among agent societies, it is not always clear how these rules mediate the interaction in a MAS. In advance, the governor agents suggested by some normative aproaches (Esteva et al. 2004) for mediating the agent interaction have a number of disadvantages: (1) they put extra computational load to the MAS by introducing a new entity, which adds complexity to the whole system; and (2) they mix the concepts of agent and infrastructure.

Another difference between the concept of agent environment and the current approaches in AIs is the lack of mechanisms to allow the perception of institutional entities and events. The existence of a mechanism to notify the agents that a new institution has been created, and to allow agents to perceive it, is crucial. Finally, current research on AIs is focused mainly on the communication events inside the system (Boella, Pigozzi, and van der Torre 2009). Although communication events are of great importance, they are not sufficient to describe all the possible interactions of the institutional entities, and furthermore, they cannot always describe the evolution of the system.

When AIs are situated in first-class environments, these drawbacks can be eliminated, because AIs can make use of the four different levels of support that agent environments offer (Weyns, Omicini, and Odell 2007):

	Basic level: enables agents to access to the deployment context. By deployment context, it is meant the external resources with which the MAS interacts;
	Abstraction level: shields low-level details of external resources, defining a standard interface that the agents can access from the environment.
	Interaction-mediation level: supports regulation of resources access and mediation of interactions.
	Reflection level: supports the modification of its composition and function during runtime. The agents can perceive the properties of the environment and interact in order to modify its state.

In order to embed these levels of support into AIs, we need to specify the appropriate type of normative systems we will use for the mediation of agent interactions. There are two approaches to define normative systems (Modgil et al. 2009):

	– Regimentation-based normative systems, in which a set of rules and protocols are defined to coordinate the behavior of the agent
	– Enforcement-based normative systems, in which the agents have the possibility to violate the systems' norms, while appropriate mechanisms monitor the agents' acts in order to track the violations.

Regimentation-based normative systems are less flexible, because the agents are not free to perform actions outside the rules defined by the normative system. The enforcement-based approach allows agents to take actions outside the rules of the normative system, but it has the drawback that sometimes the agents can behave maliciously and not be caught by the enforcer of the law (Grossi, Aldewereld, and Dignum 2006). Although proper coordination of agents is crucial, at the same time it is important to ensure the autonomy of agents. Thus, we envisage AIs as enforcement-based normative systems in which the agents are free to violate the rules of the system, but for every forbidden action, the system tracks the violation and punishes the agent to preserve its stability.

A META-MODEL FOR FIRST-CLASS ARTIFICIAL INSTITUTIONS

The Formalism Adopted: Object Event Calculus, C-Logic

In order to describe the dynamic evolution of MANET, we use the Object Event Calculus (OEC) language (Kesim and Sergot 1996). The Object Event Calculus is a dialect of the Event Calculus (EC) (Kowalski and Sergot 1986) that is suitable to represent the evolution in time of complex structures by means of events. The main advantage of using the OEC is that it determines the state of an object by assigning values to its attributes. Based on this property, it deals with the evolution of an object over time, parameterizing its attributes with times at which these attributes hold various values. The Object Event Calculus predicates that we use, for the purposes of this paper, are shown in Table 1.

TABLE 1 OEC Predicates

Clause	Predicate	Meaning
C1	holds_at(Id, Class, Attr, Val, T)	object Id of class Class has an attribute Attr of value Val at time T.
C2	broken(Id, Class, Attr, Val, Ti, Tn)	value Val of the attribute Attr for an object Id of class Class is terminated by an event which happens between time Ti and Tn
C3	attribute_of(Class, X, Type)	attribute X is an attribute of class Class
C4	attribute_of(Sub, X, Type)	attribute X is an attribute of subclass Sub
C5	instance_of(Id, Class, T)	object Id is an instance of class Class at time T
C6	removed(Id, Class, Ti, Tn)	object Id is not an instance of class Class when an event destroyed Id between time Ti and Tn
C7	assigns(E, Id, Class)	event E creates a new instance Id of class Class
C8/C9	initiates/terminates(E, Id, Class, Attr, Val)	event E initiates/terminates the value Val of an attribute Attr of an object Id of class Class

Clauses C1-C2 provide the basic formulation of OEC, deriving how the value of an attribute for a complex term holds at a specific time. Clauses C3-C4 support a monotonic inheritance of attributes names for a class limited to the subset relation. As C1-C2 describe what holds at a specific time, C5-C6 determine how to derive the instance of a class at a specific time. The effects of an event on a class are given by assignment assertions; the clause C7 states that any new instance of a class becomes a new instance of the super classes. Finally, deletion of objects is accounted for by clause C8/C9. C9 deletes single-valued attributes that have been updated.

To represent the state of the entities at a given time, we will use the C-logic formalism (Chen and Warren 1989) because, as shown in (Kesim and Sergot 1996), it has a convenient and compact syntax to represent complex structures, and it has a direct translation to the OEC. In C-logic, properties of an object are represented by labeled values, for example john[age ⇒ 28] means that john has a property age whose value is 28. Intuitively, a term like i:t[l₁ ⇒ t₁, …, l _n  ⇒ t _n ] represents an object with identity t of type i, with certain property indicated by l _i  ⇒ t _i (1 ≤ i ≤ n). In the next sections we will use C-logic for representing complex objects. For the purposes of this paper, we use a logic-programming syntax, with a Prolog-like approach in which the variables start with capital letters and the constants with lower case letters.

The MANET Meta-Model

The MANET (Multi-agent Normative EnvironmenTs) meta-model is based on the assumption that the agent environment is composed of two fundamental building blocks; (1) the physical environment, concerned with agents' interactions with physical resources and the MAS infrastructure, and (2) the institutional environment, concerned with the institutional interactions of the agents and coinciding with the notion of AIs.

Spaces and objects are first-class entities that allow agents to perceive their properties, interact, and change the state of the environment itself. Spaces can be further categorized as institutional spaces and physical spaces.

Spaces are the fundamental structural components of our model. By default in our approach, there always exists a root space, which contains all the physical laws of the system and where all the other spaces of the system are created. In direct analogy to the human reality, in that we can distinguish between the physical world and the institutional world, in MASs we can consider institutional spaces (Stratulat, Ferber, and Tranier 2009) describing the AIs in a normative system. All the institutional spaces of a MASs are situated inside the root physical space.

Analytically, a physical space describes the infrastructure of the system and the corresponding infrastructural limitations to the agents' behaviors in terms of physical rules. Institutional spaces (ISs) define a first-class representation of AIs.In general, spaces:

	– represent the boundaries of the effects for the events and the actions performed by the agents;
	– contain all the other entities of the systems (including objects and subspaces);
	– mediate the interaction of the agents by enforcing the norms of the system in response to the produced events.

Mediating the interaction means that the environment is in charge of registering that an event has happened and notifying all agents registered to the template of this event (the agents have a sensor for these types of events; Bromuri and Stathis 2009). It also implies that because spaces are the boundaries and containers of events, they manage norm violations and fulfillments. The content of each event and the combination of role/power of the agents that produced the event are always checked by the space against the corresponding norms. In case of a norm violation, a space will retrieve the information of the appropriate sanction objects and will apply them to the agent that did not comply with the rules of the system. In other words, we see institutional spaces as structures whose states exist in the physical environment and are perceivable and modifiable through the production of events. Although by default a space represents the boundary of the effects of an event, it is important to state that it is possible for the MAS designer to define events that may also be perceived on super and subspaces of the institutional space where the event is performed.

The representation of the instance of a space in terms of C-logic is as follows:

institutional_space:is ₁ [

agents ⇒ {agent:a ₁ [roles ⇒ {role:r ₁ , role:r ₂  … role:r _N }], …, agent:a _K [roles ⇒ {role:r ₁ , role:r ₂  … role:r _L }]},

institutional_objects ⇒ {inst_object:o ₁ , inst_object:o ₂  … inst_object:o _Y },

institutional_sub_spaces ⇒ {institutional_space:is ₂ , institutional_space:is ₃ , …, institutional_space:is _Z }]

where is₁ is an institutional space, which has a set of agents a₁ to a _K with different roles, a set of institutional objects o₁ to o _Y that the agents can manipulate, and a set of institutional subspaces is₂ to is _Z .

The notion of object describes first-class entities that represent virtual entities, virtualizations of external resources or web services, offering an abstraction that hides the low-level details from the agents. From the standpoint of AIs, these virtual entities can depict either physical objects or institutional objects.

On one hand, physical objects are considered to be the physical entities of the application (web services, databases, external files, etc.) that are present inside an AI. On the other hand, institutional objects are objects existing only in common agreement among the agents of an AI. Institutional objects can be further categorized as:

	– objects that can exist within the communication among the agents, such as the goods to trade in a market;
	– agreements between one or more parties;
	– sanctions for the incorrect behavior of the agent in the AI;
	– norms of an AI; and
	– objects that represent roles of agents within an AI.

Moreover, physical objects can be considered as institutional when they obtain institutional attributes during the evolution of the agent environment.

In the MANET meta-model, the notion of agent is used to describe the proactive entities that interact, thanks to the environment. For the agents, we assume a separation between a cognitive mind and a physical body with sensors and effectors as described in (Bromuri and Stathis 2009). The cognitive mind is the reasoning unit of the agents, and its role is to analyze the data received by the sensors as well as reasoning about the agent strategy. The effectors of the agent are used in order for the agent to act inside the environment. In order to describe how the agents perceive the institutional spaces with their sensors, we define the R1 and R2 clauses:

R1)notify(Class:E, Sensor, T) ← happens (E,T), E[institutional_space ⇒ IS], holds_at(IS,agent,Ag,T), holds_at(Ag,owns,Sensor,T),holds_at(Sensor,senses,Class,T).

R2)perceive (E,S,T) ← happens (E, T), perceive_institutional_space (E), E[sensor_of ⇒ S, focus ⇒ Focus, institutional_space ⇒ IS].

R1 specifies that whenever an event happens within an institutional space, such event is noticeable to the agents that are part of such space if they have a sensor that is capable to perceive such event. R2 specifies how an agent can focus to a particular institutional space and perceive its properties. The implications of rule R2 is that the agents deployed in the agent environment and occupying a place in an institutional space can perceive the institutional entities, such as sanctions and norms, in theinstitutional space.

In general, in normative systems, agents' interactions can create new institutional realities (e.g., new AIs) based on production of events. In our model, each time a new AI is to be born, a new institutional space is created, which includes all the norms, the objects, and the agents of the institution, which, combined together, constitute a first-class representation of an AI.

All the structural entities of MANET are considered OEC objects, and the relationships between them are depicted in Figure 1.

FIGURE 1 Class diagram of MANET meta-model.

An Event-System for Agent Interaction

On the basis of our model, the environment is described in terms of spaces and objects whose dynamics depend on the events that take place. Some of those events are actions performed by the interacting agents: an action is an event with an actor. In order to be able to represent the evolution of the state of the environment, it is necessary to specify our complete model of events. The taxonomy of events that we take into consideration in our system is shown in Figure 2.

FIGURE 2 Events hierarchy.

EVENTS HIERARCHY

All the events are considered physical events, because they happen inside a physical reality, having also or only institutional effects. We prefer to avoid clearly separating institutional from physical events because this leads to two different ways of producing events, and, thus, we may get into a situation where an agent can perform communicative acts without taking into consideration the physical reality in which they are situated. Physical events can be categorized into three types: (1) speech events; (2) institutional events; and (3) sensing events.

These distinctions have similarities with the event system in (Bromuri and Stathis 2009), but in this paper we further extend the hierarchy of events and introduce institutional events. Institutional events include the creation/deletion of institutional spaces and objects. The dynamic creation of first-class institutional spaces is necessary for the concrete realization of artificial institutions during the runtime evolution of the system. Events descriptions are specified in complex terms and can be perceived by any agent inside the institutional space. This property of the events allows the agents to notice every action that happens inside their institutional space. For the purposes of this paper, we simulate the evolution of the state of the environment by asserting a set of event attempts.

attempt(e1, 100). institutional_action:e1[actor ⇒ ag ₁ , institutional_space ⇒ is ₁ ]

The event description above states that an agent ag₁ is attempting to perform an action in institutional space is₁ at time.

Modeling First-Class Norms

Norms are the most important category of institutional objects. They are used to define obligations, permissions, and powers in terms of roles at design time in order to regulate the behavior of the agents inside the environment. In MANET, all types of norms are expressed as first-class institutional objects that belong to a specific space. Norms violation may trigger the application of sanctions while norms fulfillment may trigger the distribution of rewards. A generic norm is specified according to the following C-logic template:

norm:NormID[mediates ⇒ EventClass:Event, constraints ⇒ {C ₁ ,C ₂  … C _N }]

This specifies that a norm has an identifier NormID; it mediates a certain class of events EventClass with a certain C-logic description specified by the variable Event, by applying the constraints C₁,C₂ …C _n . Every norm in MANET is an extension of the generic class of norm, inheriting the attributes mediates and constraints but possibly defining further attributes according to the needs of the application. The notion of power is used to specify the fact that an agent has the power to perform a given institutional action that changes an institutional fact in a certain context. For example, the following term.

power:p ₁ [mediates ⇒ CreateSpace:Ev[actor ⇒ IDActor]@T, constraints ⇒ {check_role(IDActor, r _N )}],

describes a power rule p1, that mediates institutional actions of class CreateSpace, by applying the constraint to check the power of an agent IDActor that enters a space with role r _N to create a new space inside the old one at time T.

The concept of permission is both related to the state of the institutional space and to the concept of power. An agent can exercise its power to perform an action even if it does not have the permission to do it, but in this case the agent will be sanctioned by the system. For the purposes of this article we accept that every action is prohibited unless it is permitted and every action is permitted unless it is prohibited (lack of permission).

Obligation expresses the idea that within a given deadline the agent should produce a certain type of action. An obligation exists between two specific agents that are the debtor and the creditor of the obligation. An obligationis characterized by the instant of time when the obligation is created, a class of events that may activate or deactivate it, a content described by means of another class, and a deadline (Fornara 2011).

In order to allow agents to autonomously plan their future actions, it is crucial that obligations do not strictly constrain agents' behavior. One possible approach to this problem consists of expressing the content of norms and, therefore, of the obligations, using a class of possible actions instead of one specific action. In general, we can consider that an obligation has a set of states, and the transition from one state to another is subject to specific classes of events that happen inside the MAS, as we depict in Figure 3a.

We distinguish among five different states:

	– Created, when an obligation has been created;
	– Activated, when an event of class StartEvent has activated an obligation;
	– Deactivated, when an event of class EndEvent has canceled the obligation;
	– Fulfilled, when an event of class FulfilEvent has been produced earlier than the deadline of the obligation;
	– Violated, when an event of class FulfilEvent is not produced before the deadline of the obligation.

In most of the cases, the violation of an obligation leads to the application of a sanction to the debtor agent.

With respect to an auction protocol, we can describe the instance of an obligation as an institutional object in terms of C-logic as follows:

N1) obligation:n ₁ [mediates ⇒ Fulfill:Ev[debtor ⇒ agent:a ₁ [roles ⇒ role:auctioneer], creditor ⇒ agent:a ₂ [roles ⇒ role:buyer], item ⇒ O, institutional_space ⇒ IS]@T, constraints ⇒ {lastOffer(IS,a ₂ ,O,LastOffer),currentPrice(IS,O,CurrentPrice), equal(LastOffer,CurrentPrice)},deadline ⇒ Td, state ⇒ activated].

The above term describes an obligation that is active and that states that an auctioneer must assign the auctioned object to the buyer who made the best offer (the last offer of the whole auction). In order for the obligation to be fulfilled, the debtor agent must produce the specified event of class Fulfill before the elapsing of the obligation deadline. We can describe the state transition of the obligation from activated to fulfilled with the following OEC clause:

initiates(Fulfill:Ev[inst_space ⇒ IS],Oid, obligation, state, fulfilled) ← Fulfill:Ev[inst_space → IS], happens(Ev[inst_space ⇒ IS], T), holds_at(Oid, obligation, state, activated, T), holds_at(Oid,obligation,deadline,Td,T),T ≤ Td.

The above clause means that an event of class Fulfill will change the state of an obligation object to fulfilled, if this event has been registered and happened inside the appropriate institutional space, and the obligation is activated.

Sanctions are not norms even if they are closely linked to them because the violation of a norm can lead to the application of a specific sanction. A generic sanction is specified according to the following C-logic template:

sanction:SanctionID[penalty ⇒ EventClass:Event, constraints ⇒ {C ₁ ,C ₂ …C _N }].

We will show in the next section, in rule H1c, how sanctions are triggered in MANET. We can distinguish among four different states for a sanction: (1) created, when a sanction has been created; (2) activated, when an activate condition has been fulfilled or when an internal condition is keeping the sanction at the same state; (3) canceled, when a cancellation condition has fulfilled; (4) applied, when an event has fulfilled the condition that terminates and applies the sanction. The life-cycle of sanctions is depicted in Figure (3b).

FIGURE 3 (a) Obligation life-cycle (b) Sanction life-cycle.

Event-Based Environment Evolution

Events are mediated by the rules defined in the institutional spaces; they can actually happen on the basis of the following rules.

H1a)happens(Event, T) ← attempt(Event[institutional_space ⇒ IS], T), power(Event,T).

H1b)happens(Event, T) ← happens(Event, * T), counts_as(Event * [institutional_space ⇒ IS], Event,T).

H1a specifies that an event takes place if the agent has the power to perform such an event. H1b specifies that an event E has a further effect, that is, it may count as the happening of another event E *, where count_as/3 is an application dependent predicate.

We can specify the predicates to enforce the norms (obligations, permissions and powers) of the institution as a response to the produced events as follows:

H2)obligation(Ev[institutional_space ⇒ IS],T) ← instance_of(IS,institutional_space,T), holds_at(IS,norm_object,Oid,T),instance_of (Oid,obligation,T), apply_norm(Oid,Ev,T).

H3)power(Ev[institutional_space ⇒ IS],T) ← instance_of(Sid, institutional_space,T), holds_at(Sid,institutional_space,norm_object,Oid,T),instance_of(Oid,power,T),apply_norm(Oid,Ev,T).

H4)permission(Ev[institutional_space ⇒ IS],T) ← instance_of(IS, space,T), holds_at(IS,institutional_space,norm_object,Oid,T)

The clauses H2, H3 and H4 specify the concepts of power, obligation, and permission that define distinct types of norms. The predicate apply_norm/3 is a meta-predicate that takes the norms in the form of objects and checks them against the events produced and the constraints in the norm. This meta-predicate is implemented in Prolog as it is described in more detail in (Tampitsikas, Bromuri, and Schumacher 2011).

A special type of event is the events that apply a sanction to an agent. These events do not have an actor and they are applied by the institutional spaces to the agents as a punishment for the violation of the norms of the system.

H1c)happens(sanction:Event, T) ← obligation(Event*@T*,T), T* = T.

H1c specifies that a sanction event takes place if an obligation is holding and is not fulfilled at a given time T.

The evolution of the agent environment also includes the creation or destruction of an institutional space by an agent performing an institutional event. To do this we need to define a domain-specific assigns clause, as shown below:

assigns(E,Obj, auction) ← open_auction:E, auction_of(E,Obj).

In this way, the assigns/3 domain dependent clause deals with the creation of an auction.

When a space instantiates an artificial institution it means that the agent that will enter the space will play one of the roles defined by the artificial institution, and the space will enforce the norms defined in the institution. When a new space is created the agents in the space that contains the new one can register to the subspace, whereas, the rules that regulate the registration to the subspace belong to the containing space.

Artificial Institutions Interdependencies

Institutional spaces in our model can be created and destroyed runtime on the basis of the agents' interactions. This process can create complex topologies of institutional spaces, which can hide interdependencies affecting the agents participating in more than one of them. An example of institutional space topology is presented in Figure 4.

FIGURE 4 A sample topology in which different institutional spaces (contracts, auctions) exist simultaneously inside the energy marketplace and the agents participate in more than one of them.

In this figure we observe an instance of an e-Energy Market that may result when an market is formalized and executed. Inside this market there exist agents that participate in spaces representing contract AIs' for providing energy. At the same time, someof these agents negotiate inside spaces representing auction AIs' new contracts for energy supply from different energy retailers.

In this example we can observe two general types of AIs interdependencies:

1.	There exist institutional spaces inside other institutional spaces. For example, the energy marketplace institutional space contains four different institutional sub-spaces: one describes contracts between agents whereas the others are instances of auctions running simultaneously inside the market;
2.	There exist agents that participate in more than one institutional space simultaneously. For example, the wind energy seller agent participates in the energy selling contract space and in the energy auction space.

In the first case, problems may arise when norms regulating the super institutional space must apply to an event produced in a subinstitutional space. This is a typical problem of space hierarchies in which an institutional space has to mediate some events types inside its containing subspaces. As we have already mentioned, a space is the boundary for the effects of the events, and a norm of a space is applied as a response to an event produced inside the same space.

In order to solve this problem, we need to extend the definition of the events and the boundaries of their effects. We provide the possibility to the system designer to predefine ad-hoc types of events that can be observed outside the boundaries of the space in which they have been produced. The term “observed” here means that an event is not perceivable outside the boundaries of its space, but the super space can apply a norm as a response to the observed event. What we are actually introducing are categories of events with a field of application greater than the space where they were produced, but with the perception limitations that we have already defined for spaces.

An event of this type can be described as:

EventClass:Event[actor ⇒ ag ₁ , institutional_spaces ⇒ {institutional_space:is ₁ , … institutional_space:is _N }],

where institutional_spaces are the spaces where this event will be observable.

The second interdependency problem arises when an agent participates in more than one institutional space. In this case we may have simultaneously two possible situations:

1.	Two or more institutional spaces have seemingly nothing in common besides the fact that an agent participates in all of them.
2.	The norms defined inside one space may restrict the behavior of its participant agents in other spaces.

It is obvious that in such situations, the enforcement of norms in one space can depend on the participation of the agent in another space. In order to make it possible for a space to enforce norms of this type, we need to define norm types in which their constraints (norm conditions) are related to the participation of the agent in other spaces. These norms have the following format:

norm:NormID[mediates ⇒ EventClass:Event, constraints ⇒ {not (instance_of(IS, SpaceClass,T), holds_at(IS,agent,AID,T))}],

where the norm constraints refer to the participation of an agent AID inside another institutional space IS of class SpaceClass.

This type of interdependency can be observed in the e-Energy Market instance of Figure 4 when the following rules are inserted into an energy auction space:

	– The auctioneer is obliged by the rules of the interaction to declare a specific energy retailer agent the winner of the auction.
	– The auctioneer cannot declare an agent the winner of the auction if this agent is a participant in a contract modeled with another space.

These interdependencies can be resolved by checking the participation of the energy retailer in other spaces and by enforcing the norm types we have described.

Based on the previous described cases of interdependencies, a third category arises. Until now we have described the situation in which the participation of an agent in one space is leading to a norm violation in another space. In real scenarios it is also possible that this norm violation can affect the state of the prior space where the agent participates. Using as an example the e-Energy Market instance of Figure 4 we can suppose that the participation of an agent at an auction for a new energy contract, is restricted by a norm in the current contract as long as this is a valid contract.

For these types of interdependencies we need to introduce a new type of event, called notification events, which informs the violation of a norm type by an agent at one space to the other spaces where the agent is participating. This new type of event cannot be considered as institutional because it does not have actor and debtor agents, but spaces. These events are direct communication events between spaces belonging to the same super space, and they are triggered by the violation of specific norm types.

The format of the notification events can be depicted as:

notification:Event[actor ⇒ institutional_space:is ₁ ,debtor ⇒ {institutional_space:is ₂ , … institutional_space:is _N }, constraint_violation ⇒ C _N ],

where constraint_violation describes the performed norm violation notifying the other spaces where the agent participates.

In order for the cycle of interdependencies to close, the notification events should trigger the application of a sanction at the root space when there exists a norm conflict. In order to achieve this, we introduce a new case in which sanctions apply:

happens(sanction:Event, T) ← happens(notification:Ev(actor ⇒ is _K , debtor ⇒ is _L , constaint_violation ⇒ C _N ),T), holds_at(is _L , norm, constraints, C _N , T)

In the next section we will present and formalize these interdependencies using the e-Energy market scenario.

MODELING THE ENERGY MARKET IN MANET

In this section we illustrate how our model can be applied in realistic scenarios by using an e-Energy marketplace example. An Energy marketplace allows for the power balance of electrical power between producers and consumers based on market policies. We suppose that in order to sell its energy production, a producer is asking an employee of the marketplace to start a Dutch auction. The retailers who win these auctions gain a contract with the producers for buying their produced energy.

To model the e-Energy Marketplace, we make use of the general purpose axioms presented in previous sections and we add a set of domain-dependent axioms to deal with the interdependencies of institutional spaces created during the evolution of the marketplace. We define a set of agent roles for the performance of institutional actions in the e-Energy Marketplace. Although there can be different types of consumer and producer agents, for the purposes of this article we assume there is only one type. The agents inside the marketplace institutional space will acquire certain powers, obligations, and permissions on the basis of the role they will play: (a) Employee; the role played by an agent who represents the marketplace and is entitled to open auctions. The agent having this role can also run an auction assuming the role of auctioneer for that auction; (b) Retailer; the role played by the agent that represents an energy retail with the goal of creating energy buying and selling contracts with the producers and the potential clients; (c) Producer; the role played by an agent that is participating in the marketplace trying to sell energy contracts. (d) Consumer; the role played by an agent that is participating in the marketplace trying to buy energy contracts.

Inside a Dutch auction, the agent that participates can play the following roles: (e) Buyer; the role played by an agent that is participating to an auction trying to buy an item of interest; (f) Auctioneer; the role played by an agent that coordinates an auction; (g) Seller; the role played by an agent that delegates an auctioneer to sell an item in the Dutch auction. We describe the energy marketplace in terms of C-logic, as follows:

institutional_space:is ₁ [agents ⇒ {agent:a ₁ [roles ⇒ {role:employee}], agent:a ₂ [roles ⇒ {role:producer}, agent:a ₃ [roles ⇒ {role:retailer}, agent:a ₄ [roles ⇒ {role:retailer}, agent:a ₅ [roles ⇒ {role:producer}]}, institutional_objects ⇒ {obligation:o ₁ , obligation:o ₂ }].

An instance of the e-Energy Marketplace institutional space is presented in Figure 5.

FIGURE 5 An instance of e-Energy marketplace.

The obligation for the employee to open the auction arises after the fulfillment of the agreement between the employee and the retail agent for starting the new auction(for more details on this phase see [Tampitsikas, Bromuri, and Schumacher [2011]). The following terms describe theobligation for an employee agent to open an auction about a specific product, as well as the obligation of the auctioneer of the auction to close the auction when less than two participants have remained:

N2) obligation:o ₁ [mediates ⇒ open_auction:Ev[debtor ⇒ agent:a ₁ [roles ⇒ role:emloyee], creditor ⇒ agent:a ₅ [roles ⇒ role:producer], institutional_space ⇒ is ₁ ]@T, constraints ⇒ {starting_price(is ₁ , 100)}, deadline ⇒ 500, state ⇒ activated].

N3) close_auction_obligation:o2[mediates ⇒ close_auction:Ev[debtor ⇒ agent:a ₁ [roles ⇒ role:auctioneer], creditor ⇒ agent:a ₂ [roles ⇒ role:seller], institutional_space ⇒ IS]@T, constraints ⇒ {numBuyers(IS, NumBuyers), lessthan(NumBuyers, 2)}, deadline ⇒ 2000, state ⇒ activated].

The object o₁ represents the norm object in Figure 5. The open_auction and the close_auction event types belong to the Fulfill event category that we described in previous sections. When the auction has been created, the open auction obligation has been fulfilled and destructed as an object instance. The auction institution is represented as a new institutional space inside the e-Energy Marketplace space as depicted in Figure (6a).

FIGURE 6 (a) First type of institutional interdependencies (b) second type of institutional interdependencies.

This auction space is perceivable by the agents, which can freely enter and leave according to their interests. In the case when at a specific time period, the auction has less than two buyers, the auctioneer is forced to close the auction as stated by obligation o₂. In order for the marketplace to check whether the obligation is violated, it should observe the events produced by the auctioneer inside the auction, and here is where the first type of institutional interdependencies arises. To solvethis issue, we give the possibility to the MAS designer to predefine which events can be observed outside the boundaries of the space in which they have been produced. In order for the marketplace space to observe the close_auction event of the auction space we specify:

close_auction:ev ₁ [actor ⇒ ag ₁ , institutional_spaces ⇒ {institutional_space:is ₁ ,institutional_space:IS}].

This means that an event of class close_auction is observed inside the auction space with id IS and also inside the marketplace space with id is₁. Since the marketplace space can observe the close_auction event, it can check whether the auctioneer produced it in respect to the obligation deadline limits and thus if the obligation is fulfilled.

Inside the marketplace, consumers can also fix buying energy contracts with the retailers in Dutch auctions. An instance of such an auction is presented in Figure (6b) where we can observe the second interdependency problem that we have described in the previous section. An agent in this example is simultaneously participating at more than one institutional space: as a consumer inside a contract to buy energy from a retailer agent, and as a buyer inside an auction for a new buying contract. We suppose that inside the auction institutional space there exists a norm, which prevents the auctioneer from declaring an agent as the winner of the auction if this agent already has a contract with another retailer. In C-logic, this permission can be described as:

N4) permission:p ₃ [actions ⇒ declare_winner:Ev[debtor ⇒ agent:a1[roles ⇒ role:auctioneer], creditor ⇒ agent:a3[roles ⇒ role:buyer], item ⇒ O, institutional_space ⇒ is1]@T, constraints ⇒ {not (instance_of(IS, contract,T), holds_at(IS,agent,a1,T))}].

An auctioneer has the permission to declare as winner of the auction a buyer agent when inside the marketplace is₁ another contract does not exist in which this buyer agent participates. The apply_norm meta-predicate previously discussed queries the energy marketplace institutional space for contracts in which this agent participates. If this agent is already a member of another contract, the declare_winner event violates a norm and the auctioneer will not declare him the winner of the auction.

We also assume that inside the auction there is a sanction that punishes the candidate winner of the auction for already having a valid contract when making the highest bid for a new contract inside an auction. The penalty is preventing the agent from participating in the next ten auctions created by the retailer of the current auction. The application of the sanction event creates the sanction object instance as follows:

initiates (sanction:Ev, S ₁ , exclusion_sanction, counter, 10) ← happens(sanction:Ev).

In terms of C-logic the sanction is expressed as:

S1) exclusion_sanction:s ₁ [agent ⇒ a ₅ , penalty ⇒ enter_auction:Ev[debtor ⇒ a ₅ , auction_space:is _N [agent:a ₆ [roles ⇒ {retailer}]]]@T, constraints ⇒ {counter ⇒ 10}],

where agent a₅ is the canditate winner of the auction and agent a₆ is the retailer agent of the auction. In order to describe how the agent is excluded from the next ten auctions by this specific retailer we write the following application specific clauses:

H5) terminates (create_auction:Ev, S ₁ , exclusion_sanction, counter, V _l ) ← create_auction:Ev[auction_space:as _N [agent:agent ₆ [roles ⇒ {retailer}]]].

H6) initiates (create_auction:Ev, S ₁ , exclusion_sanction, counter, V _l ) ← create_auction:Ev[auction_space:as _N [agent:agent ₆ [roles ⇒ {retailer}]]], holds_at(S ₁ , counter, previous_value, T), assignValue(V _l , previous_value - 1).

H7) destroys (create_auction:Ev, S ₁ , exclusion_sanction, counter, V _l ) ← create_auction:Ev[auction_space:as _N [agent:agent ₆ [roles ⇒ {retailer}]]], holds_at(S ₁ , counter, previous_value, T), equal{previous_value, 0}.

The clauses H5 and H6 specify that when a new auction is created inside the marketplace with the agent a ₆ as retailer, the previous value of the sanction counter is reduced by the value of one. Clause H7 specifies that when the counter of the sanction is equal to zero the sanction object is not valid anymore and can be destroyed.

After the violation of the norm by the agent a₆, a notification event will be sent from the energy marketplace institutional space IS, which mediated the declare_winner event, to the contract space where this agent participates.

The structure of the notification event can be depicted as:

notification:Event[actor ⇒ institutional_space:is ₁ , debtor ⇒ institutional_space: is_2 constaint_violation ⇒ {holds_ at (IS, is_2, agent, a_6, T), decWinner(a_6, DecWinner),equalto(0)}}]

When the notification event informs the contract space is₂, the contract space will check whether the behavior of the agent a₆ violated any of its norms, and it will apply the corresponding sanction on exactly the same way we presented it for the auction space.

EXECUTION AND EVALUATION

For the implementation of the MANET meta-model we adopted a logic programming approach because of the formal and declarative semantics of our model, and we implemented it on top of a GOLEM (Generalized Onto-Logical Environments for MAS) platform (Bromuri and Stathis 2009). We deploy institutional spaces as GOLEM objects wherein agents reside and interact. More specifically, GOLEM agents perform acts in the environment, and the institutional spaces mediate their behavior.

For the purposes of our implementation, we have extended GOLEM by introducing an institutional layer that specifies the normative part of the environment. The institutional layer contains a number of blocks representing the different components of the normative environment (norms, sanctions, etc.). Each time an act is performed, GOLEM refers to the institutional layer in order to specify/restrict the act's institutional consequences.

For the institutional layer, we utilized a version of the OEC described in (Kesim and Sergot 1996), which is based on caching the periods of time in which an attribute of an object holds. We executed its structure using the Prolog engine and creating a top-level implementation for all the predicates we presented in this article.

In order to evaluate the MANET framework, we present an example run of the e-Energy market scenario we introduced in the previous section and its corresponding role-management protocol. We follow the animation of the protocol approach that was proposed in Artikis and Sergot (2010). The protocol that needs to be followed in order to evaluate our model can be depicted as a petri net graph, as shown in Figure 7.

FIGURE 7 Energy market role-management protocol as petri net.

The full narrative of actions of the example run is displayed in the first column of Table 2. The next three columns of Table 2 show the roles of each e-Energy market agent when participating at the different institutional spaces. To be brief the different roles are represented as follows:

TABLE 2 Energy Market Role-Management Protocol Run

Action	Market/Roles	Auction/Roles	Contract/Roles
create_auction(ag2, is2, ag3, ag4, energy)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r	ag2:au, ag3:b, ag4:s	ag1:cb, ag5:cs
enter_auction(ag1, is2)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r	ag2:au, ag3:b, ag4:s	ag1:cb, ag5:cs
take_role(is2, ag1, b)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r	ag1:b, ag2:au, ag3:b, ag4:s	ag1:cb, ag5:cs
make_offer(is2, ag1, ag2, energy, price)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r	ag1:b, ag2:au, ag3:b, ag4:s	ag1:cb, ag5:cs
declare_winner(is2, ag2, ag1, energy, price)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r	ag1:b, ag2:au, ag3:b, ag4:s	ag1:cb, ag5:cs
reject_offer(is2, ag2, ag1, energy, price)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r	ag1:b, ag2:au, ag3:b, ag4:s	ag1:cb, ag5:cs
send_notification(is2, is3, ag1, decWinner, 0)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r	ag1:b, ag2:au, ag3:b, ag4:s	ag1:cb, ag5:cs
close_auction(is2, ag2, is1)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r		ag1:cb, ag5:cs
apply_sanction(is1, ag1, exclude, counter, 10)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r		ag1:cb, ag5:cs
apply_sanction(is3, ag1, cancel_contract, time, 100)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r		ag1:cb, ag5:cs
cancel_contract(ag5, is3, ag5)	ag1:p, ag2:e, ag3:p, ag4:r ag5:r

	– Energy Market Space ⇒ s1: participant ⇒ p, employee ⇒ e, retailer ⇒ r;
	– Energy Selling Dutch Auction ⇒ s2: auctioneer ⇒ au, buyer ⇒ b, seller ⇒ s;
	– Energy Contract ⇒ s3: contract buyer ⇒ cb, contract seller ⇒ cs.

The petri net graph shows the theoretical role-management protocol of the e-Energy scenario, whereas the run described in Table 2 presents the runtime behavior of the protocol. Initially, inside the market space, agents ag₁ and ag₃ occupied the role of participant, ag₄ and ag₅ the role of retailer, while ag₂ occupied the role of the market employee. Inside the dutch auction space, ag₂ had the role of auctioneer, ag₃ the role of energy buyer, and ag₄ the role of energy seller. Finally, inside the market space, there is a contract where ag₁ has the role of the contract energy seller and ag₅ the role of the contract energy buyer. At the beginning, ag₁ was empowered to perform the enter_auction action because it occupied the role of energy market participant. Consequently, with the take_role act that followed, ag₁ became a member of the Dutch auction with the role of energy buyer. At the beginning, ag₁ was empowered to perform the enter_auction action because it occupied the role of energy market participant. Consequently, with the take_role act that followed, ag₁ became a member of the Dutch auction with therole of energy buyer.

When ag₁ entered the Dutch action, the negotiation started and ag₁ made a price offer for the selling energy to the auctioneer ag₂. At the next step, the auctioneer ag₂ tried to declare ag₁ the winner of the auction, but when the declare_winner event was checked against the norm of the Dutch auction that does not allow an agent to win unless he does not participate at another contract, the offer of ag₁ was rejected. The Dutch auction space s₂ sent a notification to the energy contract where ag₁ participated, informing it of the norm violation, and then ag₂ was empowered to close the auction by deleting all the agent roles inside it.

After the Dutch auction closed, ag₁ was sanctioned inside the market space s₁ and excluded from the next ten auctions for violating the rules of the auction. However, ag₁ was also sanctioned inside the contract space s₃ after the violation notification event was checked against the norms of the contract. The application of this sanction led to the cancellation of the contract by the seller of the contract, ag₅. The cancellation of the contract deleted the roles of ag₁ and ag₅ inside it. In the end, all the subspaces inside the market where deleted and the agents kept only their initial roles inside the market.

RELATED WORK

Colombetti and Fornara have developed OCeAN (Ontology, CommitmEnts, Authorizations, Norms; Fornara et al. 2008; Fornara and Colombetti 2009), a meta-model for the specification of artificial institutions, and a complete Agent Communication Language (ACL) that can be used to model open interaction systems. At its present stage of development, the OCeAN metamodel of artificial institutions consists mainly of the following components: (1) the constructs necessary to define the core ontology of an institution, (2) a treatment of roles and of events that are used in the specification of powers and norms; (3) a treatment of the counts-as relation, which is necessary for the concrete performance of institutional actions; and (4) a treatment of norms, used to impose obligations and prohibitions to perform certain actions on agents interacting with the system. Our work is based on the definition of artificial institutions described in the OCeAN meta-model. The most important difference between our approach and the OCeAN meta-model is that we consider institutions as first-class abstractions which allow the perception of their components (e.g., norms, objects, and sanctions), which are also described as first-class entities. Another difference is related to the types of events that are possible inside an institution. In the OCeAN meta-model, only communication events are considered, whereas in our approach we define a more detailed schema of events in order to describe all the possible situations during the evolution of an open MAS.

Artikis and Sergot in (Artikis and Sergot 2010) presented a model of executable specifications of open MAS where open MAS are considered instances of normative systems. The authors represent the social constraints (laws) of the system in terms of physical capabilities, institutional power, permission and prohibition, as well as sanctions and enforcement policies. In our model we adopt a very similar view of institutional rules based on powers that are strongly dependent on permissions, obligations, and sanctions. However, in our work we consider institutional rules as first-class entitites that can be observed by the agents, allowing them to reason about the normative constraints of the open MAS.

Another work at the same research line is the MAGE (Multi-Agent Game Environment) framework defined by Urovi and Stathis (Urovi and Stathis 2009; Urovi et al. 2010). In this framework they make use of the game metaphor to represent protocols. In particular they use the OEC formalism to represent games as first-class abstractions that evolve over time. Such games are interconnected between each other in a hierarchy composed of atomic games and composite games. The state of the composite games is defined by the relationships between the atomic games and their transitions. With respect to Urovi and Stathis, we can compare our concept of institutional space with the concept of game. Institutional spaces, as well as games, are defined in terms of the OEC, and their state evolves due to the production of events. A difference we have with the work of Urovi and Stathis is that for the moment we do not consider atomic or composite artificial institutions. Another difference is that we include the possibility of defining institutional objects, such as norms and commitments, that can be observed as part of an institution. An advantage of our formalization with respect to the one proposed by Urovi and Stathis is that we allow for norms to be observed, meaning that the agents can reason about whether complying with a norm is to their best interest.

Also related to our work is the work of Ricci and Punti to unify at one model the concepts of agents, organizations, and environments (Ricci, Piunti, and Viroli 2010; Piunti et al. 2010). This model allows for designing and programming an environment in terms of a dynamic set of first-class computational entities called artifacts, collected in workspaces. Artifacts represent resources and tools that agents can dynamically instantiate, share, and use to support their individual and collective activities. The notions of artifacts and workspaces have similarities with those of objects and spaces. But unlike Piunti et al., spaces in our approach are not just the containers of agents and objects modeling the locality of the application domain; on the contracy, they are the main enforcers of the law and the regulators of the MAS evolution.

All the above-mentioned works seem to ignore the problem of institutional interdependencies, which is gradually becoming an important topic in the research community. (Cliffe, De Vos, and Padget 2007) were among the first who studied the notion of multiple institutions. The authors specified an action language in order to model the institutional interdependencies. According to Cliffe, De Vos, and Padget, different hierarchies of institutions are possible, including governing institutions, which bring about events inside the institutions. Our idea of multiple institutions is influenced by the work of Cliffe, De Vos, and Padget. Exactly like the authors, we consider complex topologies of institutions wherein the agents can particiate simultaneously in more than one of them. One difference is that, for the moment, we do not consider governing institutions that produce events inside the institutions. However, we do consider norms of an external institution that affect the evolution of the institutions. Another difference is that in the MANET meta-model, institutional spaces are first-class citizens, which allows the agents to perceive them and potentially modify their strategies based on the insitutional interdependencies.

Finally, the work of Gaertner et al. (2007) is related to this proposal. The authors consider agents that participate in different activities defined by specific protocols. The actions of an agent inside an activity may affect its behavior inside the other activity in terms of normative positions (power, permission, obligation). In order to solve this issue, the authors propose the use of an artifact called Normative Structure, which contains the state of normative positions for each agent, according to its behavior. Unlike Gaertner et al., in MANET we do not consider norm interpendencies linked to the agents. In our model, the norm interdependencies exist among the institutions, and the agents' interactions just trigger them. The conflicts are solved as a response to specific event types produced by the agents.

CONCLUSION AND FUTURE WORK

In this article we presented an approach to deal with basic types of institutional interdependencies based on the MANET meta-model. We proposed an application-independent model of the basic institutional entities (obligation, permission, power) as well as of the event system of the MAS. We introduced a model that can handle the correlations and norm conflicts of multiple institutions at runtime, where the institutions are represented as first-class OEC objects. Through an e-Energy Marketlace scenario we presented the formalization of the basic types of the institutional interdendencies using the OEC language.

Future work implies the definition of mechanism to deal with institutions physically distributed in different hosts and how to apply norm change to our infrastructure. Another possible future development implies the definition of an agent-cognitive model that is capable to observe the norms of an institution and plan according to its needs. Finally, another interesting development is to merge existing institutions and new ones with newly defined norms that depend on the state of the previously existing institutions.