LARA Concept

LARA is intended for the simulation of citizens’ decision making in the arena of policy modeling. Being a Java library that integrates well with existing ABM frameworks such as Repast Simphony, LARA fills a gap between such frameworks with no built-in psychological foundations and full-fledged cognitive architectures. Its components of perception, memory, preprocessor, decision-making, and post-processor interact via interfaces and thus, the implementation of each one can be adapted or replaced independently.

Besides the conceptual components this pages gives an overview about central model objects (as usually exogenous to the framework), the LARA process flow, and technical components. Information about specific LARA classes is contained in the JavaDoc (see the interface starting with LARA to start).

Conceptual Components

LARA steps

Basically, LARA consists of four major conceptual components:

  1. Perceptions of the bio-physical, socio-economic (i.e. political, legal or economic matters) and social environments (e.g. social networks which support social appraisal, comparison, influence, and opinion dynamics) are stored in an agent’s Memory which supports limited capacity management and sophisticated recall of content.
  2. The preprocessor chooses one of several decision modes (habit, applying heuristics such as a decision tree, or comprehensive evaluation) and prepares behavioural options the agent may decide on (e.g. recalling currently applicable options from memory and calculating their utility considering current environmental factors).
  3. The decision-making component performs the agent’s selection process. For instance, it ranks the behavioural options according to their utility with respect to the agent’s preference structure that is defined for the goals the agent pursues.
  4. Among other purposes, the post-processor can be used to evaluate the number of behavioural options an agent has at its disposal at any given time and how well these options perform with respect to the agent’s preferences. Such an assessment of the freedom of action that citizens have under different scenarios can serve as an important indicator for political decision makers.

Model Objects

Model objects are usually not a genuine part of LARA, but the simulations model that utilises LARA. However, there are crucial interactions between LARA and these model objects, and LARA requires the realisation of certain interfaces at these objects.


  • Initializes Environment (optional), Agents
  • Triggers the agents cycle (the Model Controller triggers a new timestep through the -> Model triggers agents cycle -> Agents react) and keeps track of simulation stages
  • Holds references to important central facilities, like
    • LaraRandom
    • Integer and float point format strings
    • Eventbus
    • LaraPreferenceRegistry
    • LaraDecisionConfigRegistry
    • Current data

To enable the parallel simulation of different decision configurations (and preferences) several LaraModels can co-exist, referenced by an id object. To reduce the hassle of passing the object id to each and every LARA component, and because some components are singletons, often the agent's mandatory getIdObject() method (a method of an agent's LataComponent to be precise) is used to obtain the id object. Consequently, an agents needs to be assigned to an id object uniquely.

For may applications it is reasonable to use the agent's LaraEnvironment as id object (in case the definition of LaraEnvironments corresponds to the devision of parallel simulations).


Contains information about the environment. Agents normally belong to at least one environment.

Agent (with Component)

  • Decides about different behavioural options based on State of the environment (social, physical, etc.), its experiences, its preferences

LARA Process Flow


  • Initialize Model Controller

    The model controller sets up and initialises the model, and triggers the Eventbus (by publishing LModelInstantiatedEvent). It then drives the simulation by publishing LModelStepEvent.

  • Initialize Model

    Initialised by the model controller before it publishes . That event causes LARA to initialise its internal components.

  • Initialize Environment

    Usually initialised by the realisation of LaraModel on event of LModelInstantiatedEvent.

  • Initialize Decisions

    Instantiate LDecisionConfiguration and set LaraPreferences.

  • Initialize Agents

    Usually initialised by the realisation of LaraModel on event of LModelInstantiatedEvent. Also assign LaraDeliberativeChoiceComponent and LBehaviouralOptions.

Simulation (n timesteps)

  • Update Environment
  • For every Agent
    • Perceive
    • PreProcess
    • Decide
      • PostProcess
    • Execute


  • Close database connections and the like, when the model controller publishes .

Technical Components

To understand the internal framework and implementation, knowledge about some technical components is very useful.


The LaraEventbus provides an easy and efficient way for components to communicate with each other. The Model cycle is triggered by Events, applying a Publisher/Subscriber model:

  • Components can exchange information with a group of other components by publishing Events to the Eventbus
  • Components are notified of the occurrence of the Events they subscribed to and react on them

The eventbus was introduced to avoid complicated dependencies between components (decoupling) and to make it easy to execute tasks in parallel. Benefits include:

  1. Makes initialization of the model and its components easier
  2. Makes execution of tasks in parallel easier
  3. Components without complex dependencies can be reused much easier in other projects
  4. Allows more flexible flow control
  5. Makes unit testing easier / sometimes even possible (as less dependencies to other components exist, setting up a test case is much less complicated)

The eventbus distinguishes between internal and non-internal subscriptions to prevent the user from disturbing the LARA internal process chain. LARA internal events are pushed only to those subscribers that implement the LaraInternalEventSubscriber interface and calls the onInternalEvent() method there.

See here for more information to apply the eventbus.

Model Controller

  • Instantiates the model
  • Starts a simulation run
  • Triggers the model cycle
  • Ends a simulation run