Simulate Real-World Systems with HASH: A Step-by-Step Guide to Building Agent-Based Models

Introduction

Ever faced a problem where simple math just doesn't cut it? You know the scenario: tweaking one variable—like adding a fifth employee to a warehouse—produces baffling results. Throughput doesn't increase; it stalls. You can see the chaos, but you can't predict it with a formula. That's where agent-based modeling shines. By simulating the individual behaviors of each worker (or any entity) using code, you can explore emergent patterns and test solutions without disrupting the real world.

Enter HASH—a free, online platform that lets you build these simulations right in your browser. No downloads, no heavy installations. Just you, your imagination, and a bit of JavaScript. In this guide, you'll learn how to construct a simple agent-based model step by step, using a warehouse team as our example. By the end, you'll be ready to tackle your own complex problems.

What You Need

• A modern web browser (Chrome, Firefox, or similar)
• An internet connection
• Basic familiarity with JavaScript syntax
• A free HASH account (sign up at hash.ai)
• A real-world scenario you want to simulate (we'll use a warehouse with employees)

Step-by-Step: Building Your First Simulation

Step 1: Define Your System and Agents

Start by mapping out the key elements of your real-world system. In our warehouse example, the primary agents are the employees. Each employee has properties: location, speed, task list, and a cooperation factor. Decide what behavior you want to capture—for instance, how they move through aisles, retrieve items, and interact. Write down these attributes before coding. This mental model is crucial.

Step 2: Create a New HASH Project

Log into HASH and click “New Project.” Choose a blank template. You'll see three main areas: src (where your code lives), init.json (initial state), and globals.json (shared parameters). For simplicity, we'll keep things in the default files.

Step 3: Define Agent Behaviors in JavaScript

In the src folder, create a file called employee.js. Inside, write the logic for each agent. For example:

function behavior(state, context) {
  const { position, speed } = state;
  // Move toward a goal (e.g., shelf)
  if (state.task) {
    const nextPos = moveTowards(position, state.task.location, speed);
    state.position = nextPos;
    if (distance(position, state.task.location) < 1) {
      state.task.completed = true;
    }
  }
  // Avoid collisions with nearby agents
  const neighbors = context.neighbors();
  for (let n of neighbors) {
    if (n.position.distanceTo(state.position) < 2) {
      // Slow down or change direction
      state.speed *= 0.8;
    }
  }
  state.speed = Math.min(state.speed, 1); // restore
  return state;
}

This snippet makes agents move, complete tasks, and slow down when crowded—mirroring real-world interference.

Step 4: Set Initial Conditions in init.json

Go to init.json and define the starting state of your simulation. For our warehouse, create an array of agents with unique IDs, starting positions, and initial tasks. Example:

[
  {
    "agent_id": "worker1",
    "position": {"x": 0, "y": 0},
    "speed": 0.5,
    "task": {"location": {"x": 10, "y": 5}, "completed": false}
  },
  {
    "agent_id": "worker2",
    "position": {"x": 1, "y": 0},
    "speed": 0.6,
    "task": {"location": {"x": 10, "y": 5}, "completed": false}
  }
  // ... add more agents up to 5 workers
]

You can also add static objects like shelves by using a different agent type or a simple boundary.

Step 5: Configure the Simulation in globals.json

Open globals.json to set simulation-wide parameters, such as the warehouse size (width, height), time step, and max agents. For instance:

{
  "topology": {
    "x_bounds": [0, 20],
    "y_bounds": [0, 20]
  },
  "num_agents": 5,
  "task_difficulty": 10
}

These numbers define the playing field and affect agent behavior.

Step 6: Run and Observe the Simulation

Click the “Play” button. You'll see the agents move in real time as colored dots or shapes. Watch for emergent patterns: do workers cluster? Does throughput plateau after a certain number? Use the timeline slider to replay interesting moments. HASH provides a 2D/3D visualizer by default.

Step 7: Analyze the Output

After running for a simulated hour, stop the simulation. In HASH, you can export data (agent positions, task completions) as CSV or JSON. Use the built-in charts to plot metrics like tasks completed per agent over time. Compare runs with different agent counts (e.g., 3 vs. 5 employees) to see if your hypothesis holds.

Step 8: Iterate and Refine

Models are never perfect. Adjust parameters: change the speed, cooperation rules, or warehouse layout. Add randomness (e.g., workers occasionally stop to chat). Rerun and compare results. This iterative process reveals deeper insights. For our warehouse case, you might discover that beyond 4 workers, interference becomes detrimental—confirming your real-world observation.

Tips for Success

• Start small – model just two agents first to debug behaviors, then scale up.
• Use HASH's community library – browse pre-built simulations for inspiration; you can fork and modify them.
• Test one variable at a time – isolate the impact of, say, speed vs. task allocation.
• Document assumptions – note why you chose certain rules; it helps when sharing results.
• Leverage the forum – ask questions at hash.ai/forum; the community is active.
• Keep JavaScript simple – use primitive functions; avoid complex libraries inside HASH.

Armed with these steps, you can now model not just warehouses, but traffic, epidemics, market dynamics, or any system where individual actions produce collective outcomes. HASH puts the power of agent-based simulation in your browser—for free. Go ahead, simulate the world!