Entities
ActionUML
Describes an action in an activity diagram
When to use ...
Models where it appears:
ActivityFinal
Represents the end of an activity diagram
When to use ...
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'
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
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.
Models where it appears:
AgentModel
When to use ...
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.
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.
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
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.
Models where it appears:
ApplicationEvent
It is an event produced by an application
When to use ...
Use it to define an agent's perception
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.
Models where it appears:
AUMLAlternativeBox
It represents link of a column to another
When to use ...
Models where it appears:
AUMLAlternativeRow
It represents link of a column to another
When to use ...
Models where it appears:
AUMLComponent
When to use ...
Models where it appears:
AUMLContainer
When to use ...
Models where it appears:
AUMLInteractionDiagram
When to use ...
Models where it appears:
AUMLPort
It represents link of a column to another
When to use ...
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.
Models where it appears:
Autonomous_entity
Root concept that represents an entity with identity and that pursues goals.
When to use ...
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.
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
Models where it appears:
Column
It represents a lifeline in a AUML protocol
When to use ...
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
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
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
Models where it appears:
ControlMentalEntity
Represents an entity used in decision processes
When to use ...
Use this entity from general mental management processes
Models where it appears:
DecisionNode
Represents a node where a decision has to be made about which is the next activity
When to use ...
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
Models where it appears:
EnvironmentModel
When to use ...
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.
Models where it appears:
ForkNode
Represents a node where several activities are launched
When to use ...
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.
Models where it appears:
GeneralEvent
When to use ...
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
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.
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.
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.
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
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.
Models where it appears:
InitialNode
Represents a node where a decision has to be made about which is the next activity
When to use ...
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.
Models where it appears:
InteractionModel
When to use ...
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
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
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.
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
Models where it appears:
JoinNode
Represents a node where a decision has to be made about which is the next activity
When to use ...
Models where it appears:
Lifeline
It represents a lifeline in a AUML protocol
When to use ...
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
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.
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.
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
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
Models where it appears:
MergeNode
Represents a node where a decision has to be made about which is the next activity
When to use ...
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.
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
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.
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.
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.
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
Models where it appears:
OrganizationModel
When to use ...
Models where it appears:
Package
When to use ...
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.
Models where it appears:
Protocol
It represents an AUML protocol
When to use ...
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.
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'
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
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
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
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
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.
Models where it appears:
SubProtocol
It represents an AUML protocol
When to use ...
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.
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.
Models where it appears:
TasksAndGoalsModel
When to use ...
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
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
Models where it appears:
UMLActivityDiagram
When to use ...
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
Models where it appears:
UseCase
Describes a use case of the system.
When to use ...
Models where it appears:
UseCaseDiagram
When to use ...
Models where it appears:
View
When to use ...
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.
Models where it appears:
AHasMSManager
Association ends:
Models where it appears:
AGOInconditionalSubordinationRelationshipOrg
Association ends:
Models where it appears:
GTDecomposes
Association ends:
- GTDecomposessource (1..1):Goal
- GTDecomposestarget (1..1):Goal
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:
- Contributesource (1..1):Goal
- Contributetarget (1..*):Goal
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:
- ParticipatesInUseCasesource (1..1):AgentRole
- ParticipatesInUseCasetarget (1..*):UseCase
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:
- WFDecomposessource (1..1):Task
- WFDecomposestarget (1..*):Task
Models where it appears:
AGOClientServerRelationshipMember
Association ends:
Models where it appears:
WFSpecifiesExecution
Association ends:
- WFSpecifiesExecutionsource (1..1):Task
- WFSpecifiesExecutiontarget (1..*):Interaction
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:
- AInheritssource (1..1):Agent
- AInheritstarget (1..1):Agent
Models where it appears:
GTFails
Association ends:
- GTFailssource (1..1):Task
- GTFailstarget (1..*):Goal
- GTFailsHelperTasktarget (0..1):Task
Models where it appears:
AGOClientServerRelationshipOrg
Association ends:
Models where it appears:
AGOSubordinationRelationshipOrg
Association ends:
Models where it appears:
GTDepends
Association ends:
- GTDependssource (1..1):Goal
- GTDependstarget (1..*):Goal
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:
- GTDependssource (1..1):Goal
- GTDependstarget (1..*):Goal
Models where it appears:
AUMLUseProtocol
Association ends:
Models where it appears:
GTAndDepends
Association ends:
- GTDependssource (1..1):Goal
- GTDependstarget (1..*):Goal
Models where it appears:
ODecomposesGroup
Association ends:
Models where it appears:
IInitiates
Association ends:
Models where it appears:
Contribute
Association ends:
- Contributesource (1..1):Goal
- Contributetarget (1..*):Goal
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:
- ARoleInheritancesource (1..1):Role
- ARoleInheritancetarget (1..1):Role
Models where it appears:
AGOInconditionalSubordinationRelationshipMember
Association ends:
Models where it appears:
UMLSendsMessage
Association ends:
Models where it appears:
UMLAssociation
Association ends:
- UMLAssociationsource (1..1):UseCase
- UMLAssociationtarget (1..*):UseCase
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:
- GTSatisfiessource (1..1):Task
- GTSatisfiestarget (1..*):Goal
Models where it appears:
AGOCondSubordinationRelationshipMember
Association ends:
Models where it appears:
WFUses
Association ends:
Models where it appears:
ContributePositively
Association ends:
- Contributesource (1..1):Goal
- Contributetarget (1..*):Goal
Models where it appears: