Model Complex Systems with HASH: A Step-by-Step Simulation Guide

Introduction

Sometimes, the world doesn’t fit neatly into a simple equation. You might know that adding more hot water raises the temperature, but what happens when you have five employees in a warehouse and they start tripping over each other? Basic math fails, but a simulation can show you exactly how each worker’s behavior adds up to the final output. That’s where HASH comes in — a free, online platform that lets you build agent-based models using a bit of JavaScript. This guide walks you through creating your first simulation, from mapping out the rules to tweaking parameters until the model behaves like the real world.

What You Need

• A computer with an internet connection
• A free HASH account (sign up at hash.ai)
• Basic understanding of JavaScript (variables, functions, loops)
• A clear idea of the system you want to model (e.g., warehouse workers, traffic flow, ecosystem)

Step-by-Step Guide

Step 1: Define Your System and Variables

Before writing any code, sketch out the key components of your system. Ask yourself:

• Who are the agents? (e.g., warehouse employees, cars in traffic, bacteria in a petri dish)
• What are their properties? (e.g., speed, stamina, workload, position)
• What rules do they follow? (e.g., “If another agent is within 2 meters, slow down”)
• What outputs do you want to measure? (e.g., total throughput, average wait time)

For example, in a warehouse simulation, your agents are employees. Each has a “pace” property (units per minute) and a “collision avoidance” rule. The output is the number of boxes processed per hour. Write these down — they will become the backbone of your JavaScript code.

Step 2: Set Up a New Simulation in HASH

Log in to HASH and click “New Simulation”. Choose a blank template or a starter project. HASH works with a simulation.json file (for metadata) and one or more JavaScript files (for agent behavior).

1. Name your simulation (e.g., “Warehouse Workers”).
2. Add an init.json file to define the initial agent population. For each agent, list its starting properties.
3. Create a behaviors folder and add a JavaScript file (e.g., worker.js).

HASH provides a visual interface, but the real power is in the code editor. You can also use the “Run” button to test your model instantly.

Step 3: Write Agent Behaviors in JavaScript

Every agent in HASH has a tick() function that runs each time step. This is where you implement your rules. Start simple.

Example for a warehouse worker:

function tick() {
  // Move toward the packing station
  let dx = state.goalX - state.x;
  let dy = state.goalY - state.y;
  let distance = Math.hypot(dx, dy);
  if (distance > 0) {
    state.x += (dx / distance) * state.speed;
    state.y += (dy / distance) * state.speed;
  }
  // Check for other agents nearby
  let neighbors = context.neighbors().filter(n => n.agent_id !== state.agent_id);
  for (let n of neighbors) {
    let dist = Math.hypot(state.x - n.x, state.y - n.y);
    if (dist < 2) {
      state.speed = 0.5; // slow down to avoid collision
    } else {
      state.speed = 1.0; // resume normal speed
    }
  }
  // If at packing station, increment output
  if (distance < 0.5) {
    state.packed++;
    state.x = state.startX; // reset to starting position
    state.y = state.startY;
  }
}

Use context.neighbors() to access nearby agents, and state to read/write agent properties. HASH automatically loops this function for every agent in each tick.

Step 4: Run the Simulation and Observe

Click “Run” to start. HASH will show a real-time visualization of your agents moving. Watch the output metrics (like total boxes processed) update each tick.

You can also add a “stats” file to track custom outputs:

function statistics(state) {
  return {
    totalPacked: state.packed,
    averageSpeed: state.speed
  };
}

Examine the graphs and logs. Does the simulation match your expectations? If you see agents stuck in loops or output that doesn’t make sense, go back to Step 3 and refine the rules.

Step 5: Tweak Parameters and Iterate

Simulation is about exploration. Change one variable at a time and compare results. For example:

• Increase the number of agents from 4 to 5 — does throughput drop as expected?
• Adjust the collision threshold from 2 to 3 meters — does that reduce congestion?
• Increase agent speed — do they now collide more?

Each time, rerun the simulation and note the changes. HASH lets you save different versions of your model, so you can track your experiments.

Tips for Successful Simulations

• Start simple. Add complexity only after the basic model runs correctly. A single agent moving in a straight line is a good test.
• Use logs. Insert console.log() statements inside tick() to debug unexpected behavior.
• Validate against real data. If you have historical data (e.g., actual warehouse throughput), compare it to your simulation output to calibrate parameters.
• Document your assumptions. Write down why you chose certain rules — this helps you share your model with others.
• Join the HASH community. The platform has forums where you can ask questions and find example simulations.

With HASH, you can model systems that are too complex for equations alone. Whether you’re optimizing a warehouse, studying disease spread, or simulating traffic, the key is to iterate: define, code, run, refine. Now go build something — and watch the world come alive in your browser.