Skip Navigation

7.1: Introduction

Difficulty Level: At Grade Created by: CK-12
Turn In

Why Do We Need Agent-based Modeling?

The traditional view of modeling and simulation is very often driven by the idea of imitating some system we have observed, in order to help us understand how it works. We start with the real system and attempt to define it as being either technical- or human-based. Technical-based systems describe engineering systems, like cars, trains, ships, etc. Human-based systems describe societies, like cities, organizations, etc. Once defined, we can then observe what the system does (its functionality), what goes into the system (the input(s)) and what comes out of the system (the output(s)). Thus we can determine whether it is a closed system that works independent of other systems or an open system wherein other systems affect or are affected by our system (the relations). From this first look at the system, we start deconstructing it, identifying the individual components by their sub-functionality, inputs, outputs, and relations to other components. Each component may be built from sub-components, and so forth, such that we are reducing the system more and more until we end with the smallest components that provide some support to the required functionality.

As an example of this traditional view of modeling and simulation, suppose you have the closed, technical system of a car, and you wish to analyze how changes to the components affect its safety in a head-on collision. You can start by distinguishing between the exterior parts of the car, the interior parts of the car, and the engine and drivetrain as the three main components. Next, you go into more detail, describing the lights, the hood and trunk, doors, fenders, framing, etc. to describe the exterior. You then use the seats, dashboard, safety belts, airbags, etc. to describe the interior. And finally, you describe the main parts of the engine and drivetrain: cylinders, valves, spark plugs, pistons, crankshafts, etc. By utilizing the physical descriptions of all these parts and how they work together, you are able to develop a simulation that very closely approximates this real system. There are, however, limitations to this approach; we assume that we correctly identified the system as being closed, and that there are no hidden parameters or unobservable parts.

The same idea can be applied to more abstract, future, physics-based technical systems. Instead of the real system, the plans for the future system, which is a system that does not exist now but may be built in the future, are used as a reference to define the simulation from the top down. A big advantage of such an approach is that it is possible to play with the components and specifications to find out how the new system can be optimized. We can therefore build a model that represents the future system as close as we want it to be, and then use that model to simulate applications before building a prototype. Again, this idea works very well for well-known, closed technical systems.

Not all systems are closed technical systems that follow clearly defined and well understood theoretical principles, such as the Newtonian physics and mechanics used for cars, trains, planes, etc. Examples of these kinds of systems include storm fronts, economic behavior at the stock market, social interactions in a crowd during a demonstration, and many more. Simulation can help us to better understand these systems, but we can no longer apply the top-down approach described above. We need a new approach to do this. And this new approach requires an agent-based model.

The underlying idea is quite obvious: although we may not be able to identify and describe the behaviors of all the components within the system, we may be able to identify the main components, what they do, and how they are related. For example, we cannot describe the traffic in New York City as a function, but we know that cars – in particular yellow taxis – and utility trucks play a major role, as well as constraints imposed by traffic lights, traffic regulators, and lots of pedestrians. Instead of trying to come up with a complex fluid-mechanic solution, each taxi, car, truck, regulator, and potential pedestrian is modeled as an agent. And instead of describing the system, we describe the components, what they do, and how they interact with each other. Then we execute the simulation and observe how the overall system behaves. Essentially, the system itself is not defined in terms of overall behavior, as in the typical top-down approach. Rather, we define the components and their interplay and observe the system behavior that emerges from the bottom up.

It is because the bottom up, agent-based modeling approach allows us to simulate more complex, semi-open technical systems that we must more fully understand how they are developed and used. This learning unit will therefore introduce the various concepts of agent-based modeling necessary to allow the student to understand how to apply agent-based solutions and how to build an agent-based solution. The student will also be able to judge if agent-based modeling is the right choice to support a task, and what other possibilities – described in more detail in other units of this book – are applicable.

There are many agent-based modeling development kits available. Examples given in this unit will use NETLOGO. The development kit can be downloaded for free from the website http://ccl.northwestern.edu/netlogo/ including examples, documentation, and other resources. As this kit was developed for teaching purposes, the use is appropriate for students even with a minimal background in computer programming. Depending on the maturity level, more advanced kits can be utilized for additional assignments. A selection of alternative development kits will be given in an appendix to this unit.

What is an Intelligent Software Agent?

The meaning of the word "agent" was originally defined as "one that produces an effect," and was derived from the Latin term agere, which translates as "to drive, to act, to do." Soon, being an agent was understood as someone that acted for someone else to produce the same effect. A travel agent is doing all the work for you to plan a vacation that you otherwise would have had to do yourself: finding the best flight connection, looking for a good hotel that provides everything you want within your budget, checking for local attractions to visit, etc. The more powerful computers became, the more this type of work could be supported by computers, leading to the evolution of software agents. However, software can usually only solve exactly the problems it was designed for. The same "simple" tasks can be conducted efficiently again and again, but when an unexpected condition occurs, the computer program normally runs into problems. As a result, researchers started to work on intelligent software agents. Figure below shows the characteristics of an intelligent system.1

Characteristics of an Intelligence-based System

These ten characteristics are neither complete nor exclusive, but they represent a good hub of agreed characteristics from experts from various domains. The characteristics can be defined as follows:

  • Self-explaining: an intelligent system can explain how it came to a certain conclusion that led to the observed reaction of the system.
  • Robust: Slight changes in the environment do not lead to a failure.
  • Fault tolerant: Even when some parts are broken, the system can still function. This characteristic may include the concepts of self-evaluation and repair.
  • Adaptive: A system can adapt to a new environment that may be significantly different from the original environment.
  • Self-organizing: Intelligent systems are able to find a way to organize themselves to optimize their tasks without an internal or external authority. The structure is discovered by the systems, not programmed by their developers.
  • Deductive: Based on a set of axioms or general knowledge, intelligent systems can derive new knowledge for a particular case.
  • Learning: Intelligence-based systems are able to learn. They not only learn from their mistakes, they also learn from success and the communication thereof with others.
  • Cooperative: Intelligent systems work together with others to solve a problem.
  • Autonomous: A system is able to continue to pursue its objectives without human guidance, even in unfriendly environments.
  • Agile: Intelligent systems can rapidly and efficiently adapt to changes in the environment.

Intelligent software agents possess these characteristics.

What is Agent-based Modeling

The use of intelligent software agents provides investigators with a whole new way to build a model in which, instead of describing the system in the typical top down approach, and controlling all of the parts in order to achieve the desired functionality, each component of the system is an intelligent software agent that follows the rules that guide how they act and interact. The system behavior is not the input into the system to be modeled but the result of the observation of the interaction of the intelligent software agents.

Let’s look at an example from traffic. When you are standing on the Empire State Building in New York City and look down onto the streets and avenues, you see the flow of cars slowly moving through the city. Figure below is a photo that shows the view.

View from the Empire State Building

When you watch traffic, you observe that the cars are moving in waves through the cities. The speed of these waves is directed by the magnitude of traffic lights. The traditional approach is to describe the traffic as a wave that is made up of cars. The position of each car is determined by the system: I compute where the wave should be and then compute the positions of the cars to make up the same waves that I observe from the top of the world. Nothing is wrong with this approach, until an accident occurs somewhere and all the waveforms change.

Using agent-based modeling, the approach is as follows: we completely ignore how I interpret the picture that I see. Instead, we focus on building agents for the cars. Cars follow the streets to move from where they are towards where they want to be. If there is a red light, they stop. However, some drivers drive up all the way to the light before they brake, while others get slower and continue to roll towards the light. When the traffic light turns green, some cars accelerate immediately, trying to get going as soon and fast as possible. Others may be more focused on changing their CDs, drinking their coffee, or answering a text and need some extra time to get going. When driving, some cars like to keep no gap at all between themselves and the trunk of the car in front of them, while others leave enough space for a truck. Some cars panic and get slower when being tailgated, others start speeding. All these are possible behaviors that can be captured in rules that an intelligent software agent follows.

Figure below shows a screen shot of a traffic simulation using NETLOGO, which is part of the standard library of simulations that can be downloaded as an example from the already mentioned website. This example shows that using simple rules for car behavior can result in complex waves being observed for the overall system without having to tell any of the cars that they shall move through the city in waves. Such behavior is called emergent behavior.

Traffic Simulation with NETLOGO

Let’s summarize what we learned thus far. The traditional modeling process for systems describes the observed system behavior using equations to describe a system from the top down. The status of system attributes and components is then derived and simulated in accordance with these equations. For many systems, this is a valuable approach; approaches like system dynamics – as discussed in another chapter of this book – provided and still provide valuable insights. Intelligent software agents allow for a new viewpoint to cope with system models. Agents follow rules that guide their behavior, including collaboration with other agents. Using agents and rules to simulate components and their interactions, the system behaviors emerge from such basic descriptions from the bottom up.

In many application cases, agent-based models have been successfully applied to contribute to problem solutions that were not possible with traditional models. However, this does not prove that agent-based modeling is superior to other modeling paradigms. It just proves that certain problems are easier to solve using agent-based models.


1 Andreas Tolk, Kevin M. Adams, Charles B. Keating: “Towards Intelligence-based Systems Engineering and System of Systems Engineering,” in: Andreas Tolk and Lakhmi Jain (Eds.): Intelligence-based Systems Engineering, Intelligent Systems Reference Library, Vol. 10, Springer-Heidelberg, pp. 1-22, 2011

Notes/Highlights Having trouble? Report an issue.

Color Highlighted Text Notes
Show More

Image Attributions

Show Hide Details
Save or share your relevant files like activites, homework and worksheet.
To add resources, you must be the owner of the section. Click Customize to make your own copy.
Please wait...
Please wait...
Image Detail
Sizes: Medium | Original