# How to Create Multi-Agent Systems with NetLogo: A Complete Guide

> Learn to create multi-agent systems with NetLogo. Define agents, patches, and observers, then program parallel behaviors for emergent phenomena. A complete guide for AI beginners.

- Repository: [Microsoft/AI-For-Beginners](https://github.com/microsoft/AI-For-Beginners)
- Tags: tutorial
- Published: 2026-08-06

---

**You can create multi-agent systems with NetLogo by defining mobile agents (turtles), environmental grid cells (patches), and an observer controller, then using simple commands to program behaviors that execute in parallel to produce emergent phenomena.**

NetLogo provides a purpose-built environment for modeling **multi-agent systems** (MAS), making it accessible for beginners to simulate complex interactions. According to the microsoft/AI-For-Beginners curriculum, you can instantiate hundreds of autonomous agents, program their individual behaviors, and observe how local interactions generate global patterns like flocking, traffic flow, or disease spread.

## Understanding NetLogo's Multi-Agent Architecture

NetLogo's architecture revolves around three core components that work together to simulate multi-agent environments.

### Agents (Turtles)

**Turtles** are the mobile agents that move, sense, and act within the simulation world. You create them using the `create-turtles` command followed by a number. Each turtle maintains its own state and can execute behaviors independently.

### Patches

**Patches** represent the stationary grid squares that form the world's terrain. They cannot move but can hold values and interact with nearby turtles. Use `ask patches` to modify environmental properties, such as changing colors to simulate different terrain types.

### The Observer

The **observer** is a unique, god-like controller that manages global simulation logic. It executes `setup` and `go` procedures typically bound to UI buttons, initializing the world and stepping the simulation forward.

## Core Concepts for Creating Multi-Agent Systems with NetLogo

### Parallel Execution Model

NetLogo's **parallel execution model** means every turtle runs the same code simultaneously during an `ask` command. This eliminates the need for explicit threading or concurrency management while yielding realistic collective behavior. As implemented in the [`lessons/6-Other/23-MultiagentSystems/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/23-MultiagentSystems/README.md), this architecture enables three simple flocking rules (alignment, cohesion, separation) to generate realistic bird-flocking patterns without centralized coordination.

### Breeds for Heterogeneous Agents

NetLogo supports **breeds** to create distinct agent types with specialized behaviors. Define breeds using `breed [cats cat]` syntax, then create them with `create-cats`. This allows you to model heterogeneous populations where different agent types follow different rules, such as predators and prey or different vehicle types in traffic simulations.

### Emergent Behavior and Collective Intelligence

The lesson's discussion of **collective intelligence** and **emergentism** (found in [`lessons/6-Other/23-MultiagentSystems/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/23-MultiagentSystems/README.md)) explains why many simple agents following local rules can produce complex system-level intelligence. This property makes NetLogo ideal for studying how micro-level interactions create macro-level patterns.

## Step-by-Step Implementation Guide

Follow these steps to start building your own multi-agent system in NetLogo:

1. **Open the Models Library** (`File → Models Library`) and select a template such as *Biology → Flocking* to study working implementations.

2. **Inspect the Interface** – Examine sliders, buttons, and plots to understand how parameters expose control points for experimentation.

3. **Edit the Code** – Navigate to the *Code* tab where you define breeds, procedures, and interaction rules using NetLogo syntax.

4. **Run and Iterate** – Click the *Setup* button to initialize agents and *Go* to run the simulation, adjusting parameters to observe different emergent outcomes.

## Practical Code Examples

The following examples from the microsoft/AI-For-Beginners repository demonstrate essential patterns for creating multi-agent systems with NetLogo.

### Creating and Moving Turtles

```netlogo
create-turtles 20
ask turtles [
  forward 5
]

```

### Defining Heterogeneous Breeds

```netlogo
breed [cats cat]
breed [dogs dog]

create-cats 10 [
  set color orange
]
create-dogs 10 [
  set color cyan
]

ask cats [
  wander
]
ask dogs [
  chase cats
]

```

### Implementing Flocking Behavior

The flocking model referenced in [`lessons/6-Other/23-MultiagentSystems/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/23-MultiagentSystems/README.md) (lines 94-100) demonstrates emergent coordination:

```netlogo
to flock
  ask turtles [
    ; alignment
    let avg-heading mean [heading] of other turtles in-cone vision-angle vision-distance
    set heading avg-heading

    ; cohesion
    let center-of-mass mean [xcor] of other turtles in-cone vision-angle vision-distance
    face center-of-mass
    forward 1

    ; separation
    if any? turtles in-cone small-angle small-distance [
      rt 180
      forward 2
    ]
  ]
end

```

### Standard Setup and Go Procedures

```netlogo
to setup
  clear-all
  create-turtles 50 [
    setxy random-xcor random-ycor
    set color red
  ]
  reset-ticks
end

to go
  flock
  tick
end

```

## Summary

- **NetLogo** provides a specialized environment for multi-agent systems with three core entities: turtles, patches, and the observer.
- The **parallel execution model** allows all agents to act simultaneously using `ask` commands, eliminating complex threading code.
- **Breeds** enable heterogeneous agent populations with distinct behaviors using the `breed` keyword.
- **Emergent phenomena** arise from local interactions, as demonstrated by the flocking example in [`lessons/6-Other/23-MultiagentSystems/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/23-MultiagentSystems/README.md).
- Start with the **Models Library** templates, then modify the Code tab to customize behaviors for your specific use case.

## Frequently Asked Questions

### What is the difference between turtles and patches in NetLogo?

**Turtles** are mobile agents that can move around the world and perform actions, while **patches** are stationary grid cells that make up the background environment. Turtles interact with patches by reading patch variables or changing patch colors, but only turtles can use movement commands like `forward` or `setxy`.

### How do breeds work in NetLogo multi-agent systems?

**Breeds** allow you to define custom agent types with specific properties and behaviors using the syntax `breed [plural-name singular-name]`. Once defined, you can create instances with `create-<breed>` and write breed-specific procedures. This enables you to model complex ecosystems with predators, prey, or different social groups interacting according to distinct rule sets.

### What is emergent behavior in agent-based modeling?

**Emergent behavior** refers to complex global patterns that arise from simple local interactions between individual agents, without centralized control. In the NetLogo flocking model described in the microsoft/AI-For-Beginners repository, realistic bird flocking emerges from three simple rules (alignment, cohesion, separation) that each bird follows independently, demonstrating how collective intelligence can develop from decentralized decision-making.

### Where can I find sample NetLogo models to study?

The **Models Library** (accessed via `File → Models Library` in the NetLogo interface) contains hundreds of pre-built simulations organized by domain including Biology, Social Science, and Computer Science. Additionally, the [`lessons/6-Other/23-MultiagentSystems/assignment.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/23-MultiagentSystems/assignment.md) file in the microsoft/AI-For-Beginners repository provides guided exercises for adapting existing models to real-world scenarios.