Ayllu: Agent-Inspired Cooperative Services
for Human Interaction
Oskar Cantor, Leonardo Mancilla, Enrique González
Grupo de Investigación SIDRe, Pontificia Universidad Javeriana, Bogotá, Colombia
Abstract. Nowadays, people not only need to communicate, but also require to
cooperate in order to achieve common goals. Thus, groupware applications are
more complex, they have to satisfy new requirements of cooperation between
people in many areas such as: organizations, industries or entertainment.
Besides, due to the remarkable increment in the use of mobile devices and other
technologies, groupware has found new environments to provide solutions and
better services to end users. The Ayllu human cooperation model states that
people must interact using well defined and structured protocols as rational
cooperative agents do. This paper presents the Ayllu architecture, which is
intended to develop groupware applications with a cooperative approach, called
5C paradigm; based on software agents that act as mediators between users
working cooperatively. Cooperative services are constructed and executed by a
mechanism called volatile group. Ayllu supports the execution of cooperative
services, people can cooperate immersed in a pervasive environment, interact in
an organized fashion, conform communities and pursue common objectives
without concerning about their individual context.
1 Introduction
Most common people’s work tasks are supported by communication. Nowadays,
practically any application can be designed and implemented over different kind of
devices, from a cell phone to complex distributed information systems. People can
communicate without taking into account distance, time or place. However, new
requirements emerge beyond simple communication applications; people needs to
cooperate in order to achieve common goals. In fact, cooperation allows people to
increase productivity, to reduce costs, to conform groups based on common interests,
to negotiate, to facilitate decision making processes. For all these reasons, Groupware
CSCW applications (Computer Supported Cooperative Work), arise as an alternative
to fulfill these new requirements. CSCW applies within different contexts such as:
industry, organizations, entertainment, among others. Taking into account the variety
of devices that are available to support different applications, groupware can provide
mechanisms for communications between people in real time without taking into
account the place and respecting the individual context of each person.
Several models and tools oriented towards groupware have been developed that
incorporate agent technologies [15], providing more flexibility and scalability. Some
of the more developed frameworks of this type include the following ones: QuickStep
Cantor O., Mancilla L. and González E. (2006).
Ayllu: Agent-Inspired Cooperative Services for Human Interaction.
In Proceedings of the 3rd International Workshop on Computer Supported Activity Coordination, pages 55-64
DOI: 10.5220/0002480600550064
Copyright
c
SciTePress
[1] MOTION [2], Proem [3], eNcentive [4], DISCIPLE [5], DACIA [6], DreamTeam
[7], YCab [8], SALSA [9]. Each of these frameworks is based on a model that takes
into account different groupware-oriented requirements. The use of peer to peer
communication can be found in [2, 5, 3, 4]. Models based in N-tier architecture are
used by [2, 4, 6, 7]. The concept of interaction protocols is present in [3, 7, 8, 9] and
the notion of group services is employed in [2, 8, 9, 1]. Other interesting frameworks
that propose different groupware requirements are: COOPSCAN [10], RCSM [11],
that with [5, 7, 9, 4, 1], manage the group awareness abstraction. There also can be
found an explicit groupware replicated architecture at [5, 6, 10, 14]; some cooperation
models are introduced in [14, 15] and finally session management utilities can be
found at [4, 5, 7, 10]. Most of these approaches are focused in providing architectural
models and services to support human interaction; however, there are few works
oriented towards the way people must cooperate.
The Ayllu human cooperation model states that people must interact using well
defined and structured protocols as rational cooperative agents do. In fact, agents are
social entities acting in a proactive way to achieve goals. Cooperative agents work
together to fulfill collective goals, each agent does its best in spite of the multi-agent
system objectives. In the groupware context, humans interact with each other in order
to fulfill activities and accomplish objectives; based on this statement, in the Ayllu
model, humans can be seen as rational agents that might behave in a similar
cooperative way as agents do, and similar cooperation techniques, as those
successfully used by agents, can be used by a human community. The Ayllu
architecture includes mechanisms to facilitate the design, construction and use of
human interaction protocols based on a cooperative agent approach. In this
architecture, software agents act as mediators helping users to participate properly in
cooperative actions. The framework is based on the abstraction of cooperative
services, which include the definition of a schema where several persons participate in
a systematic way to achieve a goal. The operation of a cooperative service is
supported by the mechanism of volatile groups, which creates dynamically the
required mediator agents. The model includes agents charged of the adaptation of the
information to the user context and to different types of devices, also agents that aim
to reduce user intervention.
In this paper, the Ayllu architecture will be introduced briefly: in particular, the
important concepts of volatile groups and cooperative services. The focus of this
paper is to explain the cooperative services creation process.
2 Ayllu Architecture Model
Ayllu consists of five basic layers and an access point mechanism, called CAP. Each
layer is supported by the services provided on the lower ones. Figure 1 shows the
general structure of Ayllu architecture. A more detailed description of Ayllu can be
found in [17].
56
Fig. 1. The general architecture of Ayllu.
The five basic layers of the Ayllu architecture are the following:
1. Resources & Agent Framework Layer
: is based on the MAD model [12], allowing
to manage the limitations inherent of mobile devices. The basic agent framework
that supports all higher layers is BESA [16], which provides the infrastructure to
execute software agents.
2. Roles Layer
: is an agent-oriented layer; it associates a set of responsibilities to
generic types of agents, called roles. As new cooperative services are created, new
roles should be included. Ayllu provides some basic roles, which can be used to
create new generic cooperative services. These predefined roles include: the
Community Manager Agent role (CMA) responsible for creating the community
agents; the user Representative Agent role (RA) charged of representing the user in
its interactions with the community; the Session Manager role (SM) acts as bridge
between the user and community agents; the Interface Agent role (IA) acts as a
flexible input/output mechanism; the Community Agent role (CA) is in charge of
performing the cooperative tasks inside the volatile groups; the Administrator
Agent role (AA) performs the management of the users and groups; the Factory
Agent role (FA) responsible of the agent creation on demand.
3. Community Access Point
: the Community Access Point (CAP), provides the
access of users to the cooperative services supplied by the community layer. It has
three basic elements: the Interface Agent (IA), the Representative Agent (RA) and
the Session Manager Agent (SM). The CAP is also the one in charge of managing
the user connection state.
57
4. Community Layer: the community layer contains the user’s sessions and defines
the active volatile groups. A session is the set of agents that allow a user to
participate simultaneously in different cooperative services by means of the agents
representing him in the active volatile groups.
5. Cooperation Layer
: the cooperation layer is a user-oriented layer; it is the one in
charge of providing the high level abstraction of the available cooperative services.
The cooperative services offered by this layer provide the abstraction of
collaboration, coordination and conflict resolution mechanism in the user context.
This service abstraction offers an explicit way to access the cooperative interaction
protocols mediated by the software agents that form a community. The
programmer can design and easily include new cooperative services as required by
the application requirements.
6. Application Layer
: in the application layer resides any application that will make
use of the provided cooperative services. Normally in this layer, the cooperative
services are instantiated in terms of the application context.
3 Volatile Groups
A volatile group is a set of processes created dynamically with the purpose of
carrying out a joint task; each one of these processes represents a user. These groups
are created on demand and destroyed once the required task has been completed. In
the Ayllu context, volatile groups are formed by agents, Community Agents and
Community Manager Agents, and support the cooperative services provided by the
groupware system. The volatile groups are the basis for the accomplishment of
cooperative tasks in Ayllu. Hence, this mechanism allows the separation of the
interactions between members of the cooperative community and the user interface
access. As soon as a new cooperative service is requested by a user, a volatile group is
created to deal with all the agent-mediated interactions associated to the service.
A volatile group is composed by a facilitator agent and a set of participant agents.
The facilitator is the process that manages the group’s life-cycle. The volatile group
mechanism work in the following way (Figure 2):
1. The facilitator agent receives a service request generated by a user.
2. The facilitator agent identifies other users that could participate in the interactions
derived from the requested service.
3. The facilitator agent creates new participant agents; each one represents a user that
participates in the cooperative service.
4. While performing the service, the participant agents communicate to achieve a
well-defined interaction protocol implementing a cooperation technique.
5. Once the task has been completed the volatile group is destroyed; in some cases, an
answer can be returned to the user who made the initial request.
The volatile group mechanism can be used in a concurrent way. Several instances
of a cooperative service can operate simultaneously. Furthermore, a user can
participate in several cooperative tasks at the same time.
58
4 Cooperative Services
Ayllu proposes a new paradigm, the 5C paradigm, to manage people oriented
groupware mediated by software agents. In this paradigm, people, accessing the
system through different types of devices, are seen like agents that are part of a
community, performing their cooperative tasks by means of software agents (Figure
2). This approach gives as result an architecture for people oriented groupware in
which software agents are capable of making their own decisions on behalf of the user
without permanent human interaction. A detailed explanation of the 5C paradigm is
beyond the scope of this paper; more information about it can be found in [17].
Fig. 2. Ayllu’s general approach.
A cooperative application is implemented by a set of cooperative services. A
cooperative service facilitates the execution of a well-defined cooperative task
between concerned users. Software agents are dynamically created to perform all the
necessary tasks to achieve the purpose of the service, respecting an interaction
protocol that defines the way intentional messages with a clear semantic are
exchanged between the adequate persons. In Ayllu, this group of agents conform a
volatile group, as explained earlier. Each concerned user communicates with its
community agents through its CAP; in particular, the session manager SM act as a
bridge between the agent community and the user’s CAP.
As figure 3. illustrates, any cooperative service in Ayllu requires three basic agent
types in order to work: a Community Manager Agent (CMA), some Community
Agenst (CA) and a Factory Agent (FA). The FA is the agent in charge of creating the
CMA agent required to start a cooperative service. There’s only one FA for an entire
application and the programmer must define which services will provide the
application and the types of CMAs it creates. Once the CMA of a requested service
has been created, it perform a look up on the person’s directory to find other users
that may participate in the service execution; the CMA creates the volatile group of
CA agents, each one representing one user. These three types of agents must be
specialized by the programmer for each specific cooperative service.
59
Fig. 3. Cooperative Service creation process in Ayllu.
In order to create a cooperative service in Ayllu, six steps must be followed:
1. Identify the cooperative services that the application will provide.
2. Identify the human agents (users) that will take part in the service.
3. Identify the software agents required to perform the task and the different roles that
they might take.
4. Create an interaction diagram, including software agents and users.
5. Establish the generic classes for the service in order to define the responsibilities
for each agent (role definition). These generic classes can be reused if needed.
6. Specialize the generic classes to obtain a cooperative service to cope with an
application’s specific requirements.
These steps will be explained in detail in the next section. The basic distribution of
the Ayllu framework provides a series of cooperative services which can be used by
any groupware application. These services are based on the abstract model previously
explained. These pre-defined services include the following functionalities: Group of
Interest and Presence Detection; Distributed Artifact Search, for managing shared
resources; Chat Service provides synchronous communication; Contract Net, for task
allocation, it is a task allocation technique inherited from cooperative agents;
Messaging Service provides asynchronous communication.
The programmer can create new cooperative services to cope specific application
requirements. Remark that the Contract Net service is a good example of how multi-
agent system cooperation techniques can be adapted to be used in groupware
cooperative scenarios, many other agent cooperation techniques can be implemented.
5 Creation of Cooperative Services in Ayllu
As mentioned earlier, Ayllu allows the creation of multiple generic types of
cooperative services that can be reused in different situations. These generic services
can be specialized according to the requirements of any cooperative application.
60
5.1 Creation of Generic Cooperative Services in Ayllu
To create a generic cooperative service in Ayllu, a set of well defined steps must be
followed, as mentioned in section 4. If these steps are followed in the appropriate
way, the development of cooperative services will be more efficient and the obtained
results will also be more reliable. In this section, these steps will be explained using
the Contract Net service as an example.
1. Establish the requirements of the application in order to identify the required
cooperative services. For the Contract Net service, the main requirement is to
provide a mechanism for users to make mutual agreements for task allocation.
2. Identify the types of users that will take part in the service. Users have different
needs of information and interaction with other users, depending on the activities
they perform and the roles that each one of them has in a given context. In a
Contract Net situation, there are two types of users: the manager and the
contractor. The manager sends offers to the contractors, which can decide to
respond with a proposal; the manager analyzes the proposals and decides which
contractor must perform the task. The contractors are informed of the decision.
3. Identify the software agents required to perform the task. As mentioned earlier,
Ayllu’s cooperative services are supported on three basic agent types.
4. Create an interaction diagram to specify the relationships between the community
agents. This diagram shows all the events that the agents must handle, and will be
used later in the implementation phase. Figure 4 shows the interaction diagram for
the Contract Net service. As can be seen, once the CA has been created, the CMA
sends a task request to the CA manager. This agent sends the task request to the
CA contractors, which ask their users for a bid. Once the bids have been collected,
the CA manager selects the best ones and sends them to its user, who decides
which one fits better his needs; finally, the CA manager informs the contractors
about the decision.
Fig. 4. Contract Net service interaction diagram.
61
Notice that interaction diagrams are not intended only to describe a sequence of
activities; the main goal of interaction diagrams is to provide a mechanism to
identify and characterize interactions between the agents used as mediators.
5. Define the generic classes for the cooperative service, which implies to extend
from the generic classes provided by Ayllu. These service role classes implement
the functionality and protocol of the general agents specified in the previous steps.
The Contract Net service requires the CMACnet specialized community manager
agent and CAContractNet community agent. The second one can be built to take
one of the two roles described earlier for the service, manager or contractor. For
the Factory Agent, only the list of services that the application will provide must be
defined, in this case the Contract Net service.
6. Finally, specialize the generic service taking into account the real application
context. This procedure implies to extend the generic service role classes. This
extension normally does not include any protocol change, only the methods already
invoked by the service roles must be supplied. For instance, if the Contract Net
service is used to negotiate a medical task allocation in a telemedicine application,
the specialized agents should have the necessary knowledge to handle the relevant
information, i.e. the medical staff information or the patient’s medical history.
5.2 Creation of Specialized Cooperative Services
In order to illustrate the creation of a specialized cooperative service in Ayllu, a
telemedicine application example will be used. The first step is to define which
services will be provided by the application. An entry in the Persons Directory must
exist for each service, describing and associating it with the users that may use it
during the execution of the application. A new Factory Agent must be created
specifically for the purpose of creating the CMA agents according to the service
requirements. The Factory Agent also verifies the permissions of the user who
invokes the service. The general structure of the generic Contract Net service in Ayllu
is shown in figure 5.
The CMAContractNet class provides the functionality of a community manager
agent and also controls the volatile group life cycle. It also associates responsibilities
to the service participants: it gives the responsibilities of a contract net manager to the
user who started the service, the other users involved are granted with the contractor
responsibilities. The CAContractNet is the agent that can assume any of the two roles
defined for the generic service, as mentioned before. The CAContractNet and the
CMAContractNet do not need to be specialized if a basic Contract Net service is
required; if any modifications to the interaction protocol need to be made, inheritance
will be required in order to do so.
The ContracNet class must be implemented by inheritance to suite the specific
requirements of information. In this class, the attributes to handle the Contract Net
service interactions should be defined by the programmer.
62
Fig. 5. Generic Contract Net service structure.
In the Contract Net service, the methods that need to be implemented are
createBid and chooseBestBids. They include the application logic to
construct a proposal in response to a task request, and to evaluate the collected bids.
After completing all the specialization process, the cooperative service is ready to use
by the cooperative application designed using the Ayllu framework.
As this section shows, Ayllu provides a simple way of creating cooperative
services, reducing development times and making a contribution to the CSCW field.
6 Conclusions
The increased development of mobile computation opens the possibility to design and
implement applications that will be capable to adapt and to satisfy the present
information needs that technology users require. In particular, user mobility facilities
must be provided in order to integrate people and services in a flexible way. The
groupware paradigm has been developed during years, oriented to the traditional
desktop devices like PCs or laptops; however, taking advantage of the possibilities
offered by the new wireless technologies requires not only a technical approach, but
also new paradigms centered in buster people cooperation.
The Ayllu´s human cooperation paradigm, contemplates the use of software agents to
support people cooperation; the paradigm states that users interact to collaborate
assuming tasks, coordinate planned actions, and solve conflict using MAS inspired
techniques; people is seen like being part of a multi-agent system, they act as human
rational cooperative agents. Ayllu is not only a groupware oriented architecture
mediated by agents, but also a paradigm for groupware development. The concept of
cooperation between people is extended through the implementation of software
agents that serve as mediators for their activities, facilitating the accomplishment of a
common objective in a successful way. The basic services provided by the Ayllu
framework reduce the development time of a cooperative application. Actual work
includes the creation and implementation of new generic cooperative services inspired
from SMA techniques, and also the identification of specialized cooperative services
for a business organization environment.
63
References
1. Roth, J., Unger, C.: Using handheld devices in synchronous collaborative scenarios.
Department of Computer Science-University of Hagen (2001).
2. Kirda, E., Fenkam, P., Reif, G., Gall, H.: A service architecture for mobile teamwork.
Technical University of Vienna (2002).
3. Kortuem, G.: Proem: A middleware platform for peer-to-peer computing. Mobile
Computing and Communications Review, Volume 6, Number 4, (2002).
4. Ratsimor, O., Finin, T., Joshi, A., Yesha, Y.: eNcentive: A framework for intelligent
marketing in mobile peer-to-peer environments. Departament of Computer Science and
Electrical Engineering, University of Maryland Baltimore Country (2003).
5. Wang, W., Dorohonceau, B., Marsic, I.: Design of the disciple synchronous collaboration
framework. The State University of New Jersey (1999).
6. Litiu, R., Prakash, A.: Developing adaptive groupware applications using a mobile
component framework. Department of Electrical Engineering and Computer Science,
University of Michigan (2000).
7. Roth, R., Unger, C.: Dreamteam a platform for synchronous collaborative applications.
Department of Computer Science- University of Hagen (2000).
8. Buszko, D., Lee, W.-H., Helal, A.: Decentralized ad-hoc groupware api and framework for
mobile collaboration. Motorola iDEN Group, CISE departmen, University of Florida
(2001).
9. Rodriguez, M., Favela, M.: A framework for supporting autonomous agents in ubiquitous
computing environments. Departamento de Ciencias de la Computación, CICESE,
Ensenada, Mexico (2003).
10. Balter, R., Atallah, S. B., Kanawati, R.: Architecture for synchronous groupware
application development. HCI, Tokyo, Japan (1995).
11. Yau, S. S., Karim, F., Wang, Y., Wang, B., Gupta, S. K.: Reconfigurable context sensitive
midleware for pervasive computing. Computer science and Engineering Department,
University of Arizona (2002).
12. Botero, A., Giraldo, H., Moyano, A.: Mad: Arquitectura basada en componentes
distribuidos para dispositivos móviles. Proyecto de Grado para optar por el título de
Ingeniero de Sistemas, Pontificia Universidad Javeriana, Noviembre (2004).
13. Roth, J.: A taxonomy for synchronous groupware architectures. Department of Computer
Science - University of Hagen (2000).
14. Gerosa, M. A.: Towards an engineering approach for groupware development. Software
Engineering Laboratory, Computer Science Department, Catholic University of Rio de
Janerio (2003).
15. J. Ferber, Multiagent Systems: An Introduction to Distributed Artificial Intelligence.
Addison-Wesley, 1999.
16. González, E., Bustacara, C., Avila, J.: Besa: Behavior- oriented, event-driven social-based
agent framework.”. PDPTA’03, Las Vegas-USA, CSREA Press, vol. 3, Junio 2003, pp
1033-1039.
17. Cantor, O., Mancilla, L., González, E: Ayllu: A Cooperative Approach to Groupware
Development. In proceedings of IEEE-ICC International Conference on Communications
(2006).
64
