Entities


ActionUML

Describes an action in an activity diagram

When to use ...
focusmain
focus packmainpack
Models where it appears:


ActivityFinal

Represents the end of an activity diagram

When to use ...
focusmain
focus packmainpack
Models where it appears:


Agent

An agent entity is an autonomous entity with identity, purposes and that performs activities to achieve its goals.

When to use ... Whenever you find an entity that behaves according to Newell's definition of an agent: 'a program at the knowledge level that processes knowledge and behaves according with the rationality principle, i.e., that performs tasks only to achieve its goals'
focusmain
focus packmainpack
Models where it appears:


AgentComponent

It represents any possible component of the agent. There is no compromise in the way this component will appear in a final agent architecture. There is a compromise in that the functionality determined by this component will appear in one or several elements of the architecture.

When to use ... This component is not instantiable in diagrams. It is used in the ontology to represent an abstract component of an agent
focusmain
focus packmainpack
Models where it appears:


AgentDescription

Just indicates that in the future you should allocate here a more detailed description of conditions of goal satisfaction or failure, or interaction collaboration, or agent requirements.

When to use ... Use this only in the initial stages of the development. As the development progresses,move to GRASIAAgentDescription and others more specific.
focusmain
focus packmainpack
Models where it appears:


AgentModel

When to use ...
focusmain
focus packmainpack
Models where it appears:


AgentModelBelieve

A believe expressed with an agent model. This entity is an encapsulation for agent models that express complex requirements

When to use ... Whenever you want to express a believe about other agent abilities or mental state.
focusmain
focus packmainpack
Models where it appears:


AgentRequirementsQuery

Describes a running instance of an agent by any kind of expression. This is useful to denote groups of agents. In that case the AgentRequirementsQuery will represent any of the members of the group

When to use ... Use it to represent what kind of agents you want to interact with. Sometimes this concept can be replaced by equivalent diagrams expressed with ConcreteAgents. However, using AgentRequirementsQuery you assume that there will be a query to some service in order to determine valid agents to perform certain operation.
focusmain
focus packmainpack
Models where it appears:


AOPMentalStatePattern

The mental state of the agent is expressed the Agent0 language. This language in described in the Agent Oriented Programming paper from Shoham. No syntax is verified.

When to use ... When the final implementation language it is Agent0
focusmain
focus packmainpack
Models where it appears:


Application

An application is wraper to computational system entities. By 'computational', we mean 'having an interface and a concrete behavior'.

When to use ... Whenever you have some system entity (physical) that you cannot categorize as an agent, organization, or resource. Use this entity when you do not know from the beginning further details of this entity.
focusmain
focus packmainpack
Models where it appears:


ApplicationEvent

It is an event produced by an application

When to use ... Use it to define an agent's perception
focusmain
focus packmainpack
Models where it appears:


ApplicationEventSlots

An application event that determines the information that transmits as slots

When to use ... Use this in the early design to define exactly what information is required by tasks or goals (information from satisfaction conditions) to process them.
focusmain
focus packmainpack
Models where it appears:


AUMLAlternativeBox

It represents link of a column to another

When to use ...
focusmain
focus packmainpack
Models where it appears:


AUMLAlternativeRow

It represents link of a column to another

When to use ...
focusmain
focus packmainpack
Models where it appears:


AUMLComponent

When to use ...
focusmain
focus packmainpack
Models where it appears:


AUMLContainer

When to use ...
focusmain
focus packmainpack
Models where it appears:


AUMLInteractionDiagram

When to use ...
focusmain
focus packmainpack
Models where it appears:


AUMLPort

It represents link of a column to another

When to use ...
focusmain
focus packmainpack
Models where it appears:


AUMLSpecification

A description of an interaction using AUML protocol diagrams. This implementation is still alpha, but it can be used to generate most of the diagrams mentioned in the last draft from AUML. Use this kind of specficiation when you look for a more conventional notation. In principle, AUML diagrams and GRASIA diagrams are equally expressive, but AUML diagrams are harder to parse in order to generate code

When to use ... Use this kind of diagrams in design stage and move to GRASIA digrams to facilitate the implementation of code generation facilities.
focusmain
focus packmainpack
Models where it appears:


Autonomous_entity

Root concept that represents an entity with identity and that pursues goals.

When to use ...
focusmain
focus packmainpack
Models where it appears:


AutonomousEntityQuery

Represent an instance of an agent or a set of agents in runtime. We can refer to that running instance in different ways: with identifiers, with query-like expressions, etc. There are concretions of this entity to represent these different ways of referring to agents

When to use ... Whenever you want to express a running instance of an agent without an special concern of the type of agent. Use this entity in the initial stages and move to more concrete entities as the development progresses.
focusmain
focus packmainpack
Models where it appears:


Believe

A believe is a set of asserts that are not certainties, just expectations

When to use ... Use it to define what you expect from other agents
focusmain
focus packmainpack
Models where it appears:


Column

It represents a lifeline in a AUML protocol

When to use ...
focusmain
focus packmainpack
Models where it appears:


Compromise

A compromise is an entity expressing that an agent has to execute a task due to a request performed by other agent

When to use ... Whenever you want to register the need to execute tasks due to past requests of other agents
focusmain
focus packmainpack
Models where it appears:


ConcreteAgent

An running instance of an agent. These isntances can be associated to agents to make explicit to what type of agent they refer to. Concrete Agents can be used in almost the same places as the agent concept

When to use ... Use it to represent the dynamics of the agent. By associating these entities with mental states, you are represeting mental states to be achieved at some time in the execution. By associating these entities to tasks or roles or organizations or organizations group, you are expressing that the agent will have to be able to execute a task, play a concrete role, belong to an organization or a group. Use it also to express required features in agents, for instance, to describe what tasks you need that another agent do for your
focusmain
focus packmainpack
Models where it appears:


ConditionalMentalState

A mental state that adds extra information about what conditions must satisfy the entities aggregated in a mental state. Entities in a mental state can be labeled. These labels are used inside the mental state condition.

When to use ... Use conditional mental states at the design stage to determine what you require from each mental entity at a certain moment
focusmain
focus packmainpack
Models where it appears:


ControlMentalEntity

Represents an entity used in decision processes

When to use ... Use this entity from general mental management processes
focusmain
focus packmainpack
Models where it appears:


DecisionNode

Represents a node where a decision has to be made about which is the next activity

When to use ...
focusmain
focus packmainpack
Models where it appears:


EnvironmentApplication

It represents and application that already exists in the environment that surrounds our MAS. An Application is a wrapper of an element that it is not an agent, nor a resource. You can configure methods in the application and relate this application with agents. Applications define agents perception.

When to use ... Identify these entities early in the beginning of the development. They correspond to other systems that are already implemented and with which we will have to interact. The level of detail can be increased in further stages by providing accurate descriptions of the application's methods and events produced by the application
focusmain
focus packmainpack
Models where it appears:


EnvironmentModel

When to use ...
focusmain
focus packmainpack
Models where it appears:


Fact

Describes an information that the agent accepts as reliable. This general entity contains this information in the description field.

When to use ... Use them to express past experience of the agent, information passed from task to task, and other kind of information assumed as reliable by the agent.
focusmain
focus packmainpack
Models where it appears:


ForkNode

Represents a node where several activities are launched

When to use ...
focusmain
focus packmainpack
Models where it appears:


FrameFact

It is a fact whose informatino is contained in its slots

When to use ... Use this entity in advanced development stages where you can provide types for the information collected.
focusmain
focus packmainpack
Models where it appears:


GeneralEvent

When to use ...
focusmain
focus packmainpack
Models where it appears:


Goal

According to the BDI model, a goal is a desired state that an agent wants to reach. In planning, a goal is represented by a world state. Here a goal is an entity by itself, however can be related with a representation of the world state using satisfaction relationships with tasks. This relationships contains references to descriptions of mental states of agents, so they refer to the image of the world that agent have

When to use ... Use goals to represent states of the world to achieve. These states of the world can be represented by sets of mental entities associated to mental states. Tasks of the agents should provide media to achieve goals. Also take into account that goals may fail. There are also relationships that can represent this aspect
focusmain
focus packmainpack
Models where it appears:


GRASIAAgentDescription

Contains a reference to an agent model. With this model you describe conditions of goal satisfaction or failure, and interaction collaboration. Usually, this is achieved associating mental states to an instance of ConcreteAgent or AutonomousEntityQuery. This instance should be understood as the executor of the task or the performer or colaborator in an interaction unit. You also can use common associations in these diagrams to represent abilities required or other qualities.

When to use ... Use GRASIAAgentDescription when you are in advanced development stages. These descriptions are very detailed and should provide enough information for most implementations.
focusmain
focus packmainpack
Models where it appears:


GRASIAMentalStatePattern

Describes an agent mental state using agent models. In these models you are expected to have only an instance of AutonomousEntityQuery associated with a mental state, and this mental state with required mental entities. Another alternative is to have a conditional mental state entity that allows to express conditions over identified mental entities

When to use ... If you have not decided yet what implementation language to use, this approach is the perfect choice. Agent models can be translated with little effort to the implementation language you decide.
focusmain
focus packmainpack
Models where it appears:


GRASIASpecification

A description of an interaction using GRASIA elements. This description allows to talk about the technology used to transfer information from one agent to another, refer to the mental conditions that must meet initator and collaborators at each step, what tasks will be executed and when, and what is the execution order of the different communication acts.

When to use ... Use this kind of diagrams in design to generate an accurate description of what kind of interaction you wish. In the analysis just use UML Collaboration diagrams.
focusmain
focus packmainpack
Models where it appears:


InformationMentalEntity

An entity that contains information about the world.

When to use ... Use them to represent different aspects of the world's perception or agent state
focusmain
focus packmainpack
Models where it appears:


INGENIASUseCase

This use case is configured with information about preconditions and postconditions, as well as information of the different interactions that may appear

When to use ... In later analysis to describe with agent models and interaction models the use case. You can associate as many agent and interaction models as you want, but with some restriction: scenarios are detailed with interaction models, preconditions and postconditions with agent models.
focusmain
focus packmainpack
Models where it appears:


InitialNode

Represents a node where a decision has to be made about which is the next activity

When to use ...
focusmain
focus packmainpack
Models where it appears:


Interaction

Represents an interaction between two or more agents or roles. There can be only one initiator and at least one collaborator. An interaction also details the goal that pursues. This goal should be related with the goals of the participants.

When to use ... Whenever you want to express interaction among agents. It can be used initially to just state that there is an interaction and that it has a purpose. In advanced stages, this entity can be further detailed by associating specification entities specialised in different notations, like UML-collaboration diagrams.
focusmain
focus packmainpack
Models where it appears:


InteractionModel

When to use ...
focusmain
focus packmainpack
Models where it appears:


InteractionUnit

Interaction among actors can be described in terms of units of interaction. A unit of interaction can be a message passing, a shared tuple read/write, a remote method invocation, an action over the environment,... This entity serves as an abstraction of all the existing ways an agent can interact with another. To characterize interaction units, the user can associate an speech act with each interaction.

When to use ... Use it later in the design to provide protocol descriptions suitable for implementation
focusmain
focus packmainpack
Models where it appears:


InternalApplication

It is an application that will be developed for this system.

When to use ... You can use these entities as a representation of internal components of agents or components shared by several agents
focusmain
focus packmainpack
Models where it appears:


IUConcurrence

It is a container of interaction units. It represents a non-deterministic execution order of a set of interaction units.

When to use ... You want to represent several possibly concurrent interaction units.
focusmain
focus packmainpack
Models where it appears:


IUIterate

It is a container of interaction units. It represents a repetitive execution of a set of interaction units. The loop finishes when the next interaction unit, to which IUITerate is connected, appears, or when the number of iterations is satisfied. The number of iterations is a parameter.

When to use ... You want to represent a loop with several interaction units. In the numberIterations field you can use notation from UML to represent the iteration
focusmain
focus packmainpack
Models where it appears:


JoinNode

Represents a node where a decision has to be made about which is the next activity

When to use ...
focusmain
focus packmainpack
Models where it appears:


Lifeline

It represents a lifeline in a AUML protocol

When to use ...
focusmain
focus packmainpack
Models where it appears:


MentalEntity

It is any element that may form part of the mental state of an agent

When to use ... Use mental entities as an abstraction to define high level mental state management functions or decision procedures
focusmain
focus packmainpack
Models where it appears:


MentalState

A mental state represents the mental state of an agent in a certain moment. A MentalState is an aggregate of mental entities.

When to use ... Whenever you want to express what mental entities an agent is supposed to have at activation at the beginning. This is expressed in an agent model by associating an agent entity to a mental state. Whenever you want to express a intermediate state of the agent. You also use an agent model, but instead of an agent entity, you use an autonomous entity query. This entity represent an instance of an agent in runtime. You can express the type of the agent, or assume that its type is deduced from another diagram that contains a reference to this one. See Autonomous Entity Query.
focusmain
focus packmainpack
Models where it appears:


MentalStateManager

An agent has a mental state upon which the agent takes decisions. This mental state is an aggregate of mental entities (believes, facts, events, etc.). As an aggregate, the mental state must be managed. Say that management of mental state consists of determining how new mental entities are added, how to maintain consistency, and how to remove entities. To specify these elements you can use description field of the entity or also task and goal models. If you use task and goals models, you can detail which management tasks exist and how they act. In these diagrams, tasks can be associated to mental entities by other relationships different from consumes or produces. For instance, you can say that a task create mental entities or removes mental entities depending on certain conditions. To express these conditions, we use MentalStatePatterns.

When to use ... Use this entity to associate mental state management concerns. In the initial stages, just provide informal specifications. In advanced stages, use task and goals diagrams.
focusmain
focus packmainpack
Models where it appears:


MentalStatePattern

It is a description of what mental state is required from an agent or set of agents. You can do this in many ways depending on the target platform you are using. For instance, you may describe the mental state with an PROLOG expression, an AOP expression (like those described in the Shoham's paper), or an GRASIA specification (based on agent models)

When to use ... Whenever you want to express a mental state of an agent. Depending on the kind of target platform, move to the most adequate subconcept
focusmain
focus packmainpack
Models where it appears:


MentalStateProcessor

The agent takes decisions basing upon its mental state. There is an entity that supports management of the mental state of the agent (MentalStateManager) and this entity that represents the decision capabilities of the agent. As the MentalStateManager you can describe the MentalStateProcessor using tasks and goals diagrams

When to use ... When you want to talk about decision procedures of the agent
focusmain
focus packmainpack
Models where it appears:


MergeNode

Represents a node where a decision has to be made about which is the next activity

When to use ...
focusmain
focus packmainpack
Models where it appears:


MessagePassing

It represents a message exchange among two actors

When to use ... Use it to represent abstract message services without detailing their nature. Message passing is supposed to be asynchronous.
focusmain
focus packmainpack
Models where it appears:


Method

A conventional object method

When to use ... To represent operations in applications. These operations can be implemented as you prefer, as computational tasks, or as object's methods
focusmain
focus packmainpack
Models where it appears:


MethodParameter

A method parameter

When to use ... It is the argument of a method defined in an application. Use it to parameterize your methods determining the type and name of the arguments. You can optionally define values as well. These values can be interpreted as default ones.
focusmain
focus packmainpack
Models where it appears:


NaturalLanguageAgentDescription

Provides an natural language description of an agent. This kind of descriptions is used to represent conditions of goal satisfaction or failure, and interaction collaboration.

When to use ... Use this only in the initial stages of the development. As the development progresses, move to GRASIAAgentDescription and others more specific.
focusmain
focus packmainpack
Models where it appears:


Organization

An organization is a set of agents, roles and resources that get together to achieve one or several goals. Inside an organization there are not other organizations, just groups. You can think of an organization as an enterprise. Internally it is composed by departments that may be restructured without affecting the external image of an enterprise.

When to use ... Use organizations as higher grouping elements. Identify them soon in the beginning. Organizations may not be required if you have one or two agents. It is reccomendable to use them when the number of agents, roles or resources becomes difficult to handle. Refine organizations using groups.
focusmain
focus packmainpack
Models where it appears:


OrganizationGroup

A group contains other groups, roles, agents, applications, or resources. It represents the structure of an organization.

When to use ... Whenever you want to structure the elements inside an organization. If you have only one group, perhaps you do not need any organization.Groups, and organizations as well, are useful when the developer foresees a high number of agents that may be working together. You can think of an OrganizationGroup as departments of an enterprise
focusmain
focus packmainpack
Models where it appears:


OrganizationModel

When to use ...
focusmain
focus packmainpack
Models where it appears:


Package

When to use ...
focusmain
focus packmainpack
Models where it appears:


PROLOGAgentDescription

Provides an prolog based description of an agent. There is no syntax check here. This means that we assume that you write down prolog code. This kind of descriptions is used to represent conditions of goal satisfaction or failure, and interaction collaboration.

When to use ... Initially use AgentDescription or NaturalLanguageAgentDescription. As the development progresses, move to GRASIAAgentDescription. Use this element when you expect to use PROLOG as implementation language for the control of your agent.
focusmain
focus packmainpack
Models where it appears:


Protocol

It represents an AUML protocol

When to use ...
focusmain
focus packmainpack
Models where it appears:


RemoteProcedureCall

This is an classic technology. It consists on invoking methods on objects allocated on other machines as if they were in the same local. It assumes that you have to produce an interface for the remote object.

When to use ... This technology is one of the most widespread. Use it if you do not want specially FIPA-like communication facilities.
focusmain
focus packmainpack
Models where it appears:


Resource

Describes a resource according to TAEMS notation. Opposite to TAEMS, there is no distinction between consumable and non-consumable resources.

When to use ... Use this entity when you want to represent some non-functional requirements, like 'keep the bandwidth usage between this value and this', or 'do not use more than X percent of CPU time', or 'we require that at least X file descriptors be available'
focusmain
focus packmainpack
Models where it appears:


Role

A role is a self-contained grouping of functionalities. When an agent plays a role we want to express that you have to to execute tasks associated to a role and participate in the same interactions that role.

When to use ... Use roles when you find set of tasks that could be executed by different types of agents
focusmain
focus packmainpack
Models where it appears:


ShareTouple

Indicates that in the implementation a shared touple communication techonology will be used. Since interaction units transmit information from initiator to collaborators, this interaction unit will be translated as 'leave in a shared tuple space the information produced by this task and expect it to be read by collaborators'.

When to use ... Use this interaction unit when you intend to use JavaSpaces or other similar techonologies to get in touch different agents
focusmain
focus packmainpack
Models where it appears:


Slot

It is a common slot used only in Frame Fact entity. Each slot could be interpreted in the implementation as an attribute in an object or as a CLIPS slot in a CLIPS fact.

When to use ... It can be used only ni FrameFact entities
focusmain
focus packmainpack
Models where it appears:


Specification

A general concept to describe the specficiation of an interaction. An interaction can be described in many ways and with different formalisms. This concept serves to abstract from concrete specification methods

When to use ... Use it in early stages to associated text based descriptions to the interaction and later on migrate to more concrete specification mechanisms
focusmain
focus packmainpack
Models where it appears:


StateGoal

This specialization of Goal is associated with a state that represents the lifecycle of a goal according to INGENIAS. - Satisfied: means that this goal has been achieved - Failed: means that this goal could not be achieved - Pending: the goal has been activated and is waiting for possible refinements - Refined: the goal has been refined into different subgoals. SubGoals are determined with - Solving: there is a task that can satisfy this goal and it has been executed Field Goal refers to the goal that is being described.

When to use ... This entity contains information about a goal in runtime so it is recommended to use it only to express required mental states of agents. Note that there is a reference to the original goal in case you need to represent different states of the same goal. Use this entity when you plan to characterize goals with a state that fits into the lifecycle described in INGENIAS.
focusmain
focus packmainpack
Models where it appears:


SubProtocol

It represents an AUML protocol

When to use ...
focusmain
focus packmainpack
Models where it appears:


SymbolicMentalStatePattern

You express a mental state using common expressions. Depending on the language you use, you can decide that you need a more specific type of SymbolicMentalStatePattern

When to use ... If you want to use logics to express a mental state or some agent programming language. Later on, you can substitute these units by more concrete entities.
focusmain
focus packmainpack
Models where it appears:


Task

Tasks is the encapsulation of actions or non-distributable algorithms. Tasks can use Applications and resources. Tasks generate changes in the mental state of the agent that executes them. Changes consist of: (a) modifying, creating or destroying mental entities; or (b) changes in the perception of the world by acting over applications (applications act over the world producing events, that are perceived by the agent). Though tasks can be also assigned to roles, at the end, it will belong to an agent.

When to use ... Whenever you want to represent an activity or an ability associated to an agent or role. You can use them also to express activities performed in a organization. Finally, you can use them also to express management or decision taking activities.
focusmain
focus packmainpack
Models where it appears:


TasksAndGoalsModel

When to use ...
focusmain
focus packmainpack
Models where it appears:


TextNote

A text note is simply an graphic object that shows text explaining details of a diagram.

When to use ... Whenever you want to clarify some aspect of a diagram
focusmain
focus packmainpack
Models where it appears:


TextUseCase

A text use case is an UML use case whose description is supplied as natural language text

When to use ... Use text use cases as a first refinement of conventional UML use cases. Then move to others like INGENIASUseCase
focusmain
focus packmainpack
Models where it appears:


UMLActivityDiagram

When to use ...
focusmain
focus packmainpack
Models where it appears:


UMLSpecification

A specification of an interaction that uses UML concepts. In INGENIAS it is assumed that the user will apply collaboration diagrams as specification mechanism

When to use ... Use it to provide a initial detailed description of the interaction. Later on, move to AUML diagrams or GRASIA specifications
focusmain
focus packmainpack
Models where it appears:


UseCase

Describes a use case of the system.

When to use ...
focusmain
focus packmainpack
Models where it appears:


UseCaseDiagram

When to use ...
focusmain
focus packmainpack
Models where it appears:


View

When to use ...
focusmain
focus packmainpack
Models where it appears:


Workflow

A workflow is an abstraction to a process that has been automatised using activities and identifying responsibility relationships.

When to use ... Use workflows to represent tasks executed by different agents or roles. The workflow description can be complimented with interactions to determine in what moment a task is executed.
focusmain
focus packmainpack
Models where it appears:


AHasMSManager

Association ends:
Models where it appears:

AGOInconditionalSubordinationRelationshipOrg

Association ends:
Models where it appears:

GTDecomposes

Association ends:
Models where it appears:

WFResponsible

Association ends:
Models where it appears:

AGOCondSubordinationRelationshipGroup

Association ends:
Models where it appears:

OHasMember

Association ends:
Models where it appears:

EPerceivesPolling

Association ends:
Models where it appears:

WFParticipates

Association ends:
Models where it appears:

WFDecomposesWF

Association ends:
Models where it appears:

UIInitiates

Association ends:
Models where it appears:

ContributeNegatively

Association ends:
Models where it appears:

WFUsesMethod

Association ends:
Models where it appears:

UISelection

Association ends:
Models where it appears:

EPerceivesNotification

Association ends:
Models where it appears:

OHasWF

Association ends:
Models where it appears:

ParticipatesInUseCase

Association ends:
Models where it appears:

GTCreates

Association ends:
Models where it appears:

AGOInconditionalSubordinationRelationshipGroup

Association ends:
Models where it appears:

AUMLSendSimple

Association ends:
Models where it appears:

WFProduces

Association ends:
Models where it appears:

GTPursues

Association ends:
Models where it appears:

ODecomposesWF

Association ends:
Models where it appears:

EPerceives

Association ends:
Models where it appears:

WFDecomposes

Association ends:
Models where it appears:

AGOClientServerRelationshipMember

Association ends:
Models where it appears:

WFSpecifiesExecution

Association ends:
Models where it appears:

AInstanceOf

Association ends:
Models where it appears:

AGORelationshipGroup

Association ends:
Models where it appears:

AGORelationshipMember

Association ends:
Models where it appears:

AInherits

Association ends:
Models where it appears:

GTFails

Association ends:
Models where it appears:

AGOClientServerRelationshipOrg

Association ends:
Models where it appears:

AGOSubordinationRelationshipOrg

Association ends:
Models where it appears:

GTDepends

Association ends:
Models where it appears:

Includes

Association ends:
Models where it appears:

IHasSpec

Association ends:
Models where it appears:

WFPursue

Association ends:
Models where it appears:

EResourceBelongsTo

Association ends:
Models where it appears:

WFConsumes

Association ends:
Models where it appears:

AHasMSProcessor

Association ends:
Models where it appears:

AGOSubordinationRelationshipGroup

Association ends:
Models where it appears:

DecisionNodeInput

Association ends:
Models where it appears:

GroupBelongsToOrganization

Association ends:
Models where it appears:

AContainsME

Association ends:
Models where it appears:

GTOrDepends

Association ends:
Models where it appears:

AUMLUseProtocol

Association ends:
Models where it appears:

GTAndDepends

Association ends:
Models where it appears:

ODecomposesGroup

Association ends:
Models where it appears:

IInitiates

Association ends:
Models where it appears:

Contribute

Association ends:
Models where it appears:

AGORelationshipOrg

Association ends:
Models where it appears:

AHasMS

Association ends:
Models where it appears:

UMLDescribesUseCase

Association ends:
Models where it appears:

IColaborates

Association ends:
Models where it appears:

GTAffects

Association ends:
Models where it appears:

UIPrecedes

Association ends:
Models where it appears:

ARoleInheritance

Association ends:
Models where it appears:

AGOInconditionalSubordinationRelationshipMember

Association ends:
Models where it appears:

UMLSendsMessage

Association ends:
Models where it appears:

UMLAssociation

Association ends:
Models where it appears:

OHasGroup

Association ends:
Models where it appears:

WFResponsable

Association ends:
Models where it appears:

WFContainsTask

Association ends:
Models where it appears:

WFConnects

Association ends:
Models where it appears:

Extends

Association ends:
Models where it appears:

GTInherits

Association ends:
Models where it appears:

AUMLSelection

Association ends:
Models where it appears:

UIColaborates

Association ends:
Models where it appears:

WFPlays

Association ends:
Models where it appears:

AGOClientServerRelationshipGroup

Association ends:
Models where it appears:

GTDestroys

Association ends:
Models where it appears:

IPursues

Association ends:
Models where it appears:

ApplicationBelongsTo

Association ends:
Models where it appears:

AGOSubordinationRelationshipMember

Association ends:
Models where it appears:

AGOCondSubordinationRelationshipOrg

Association ends:
Models where it appears:

GTSatisfies

Association ends:
Models where it appears:

AGOCondSubordinationRelationshipMember

Association ends:
Models where it appears:

WFUses

Association ends:
Models where it appears:

ContributePositively

Association ends:
Models where it appears: