The HADR game

HADR means Humanitarian Assistance and Disaster Response. In this workshop, your team will build an agent that dispatches limited fire trucks through a (simulated!) disaster. If HADR usually means High Availability and Disaster Recovery in your work, this is the other HADR.

For now, launch the game and learn the rules and objectives. Do not connect the game to Claude Code yet; that begins in Skills, tools, and MCPs.

Your mission

You are building an agent that dispatches fire trucks in a disaster scenario. You begin by knowing the map, road graph, where your fire trucks are, and what they can see; your agent receives human-language reports that may be late, incomplete, duplicated, inaccurate, or false. Your goal is to turn those reports into a persistent picture of suspected incidents, decide what to trust, and dispatch trucks before fires spread, buildings collapse, and people get hurt.

The HADR field display mid-episode: a fire truck en route to a burning building while human calls stream into the reports feed

Start with the operator

Before looking at the pipeline, consider the product problem. Who is making the dispatch decision? What makes that decision difficult? What information do they need, and what failure are they most afraid of?

Keep those questions in mind as you learn the game. In the next session, you will use Claude to investigate them before deciding what the system should do.

Design

You’ll build a pipeline that turns messy human-language contacts into dispatched trucks, with the aim of saving as many buildings and lives as possible:

flowchart LR
    subgraph Intake["Intake (Agents)"]
        i1["'smoke near the<br/>school on 5th'"]
        i2["'building fire on Elm St,<br/>people inside'"]
        i3["'fire is out at<br/>the school now'"]
    end

    r{"Reconciliation (Code)<br/>match to known incidents"}

    subgraph Incidents["Incidents (Memory)"]
        n1["1: School, 5th Ave"]
        n2["2: Elm St"]
    end

    subgraph Dispatch["Dispatch loop (Agent)"]
        plan["plan"] --> act["act"]
        act --> plan
    end

    subgraph Trucks["Fire trucks"]
        t1["truck A"]
        t2["truck B"]
    end

    i1 --> r
    i2 --> r
    i3 --> r
    r -- "update" --> n1
    r -- "new" --> n2
    n1 --> plan
    n2 --> plan
    act <--> t1
    act <--> t2

Stage	What it does	Kind
Intake	Normalize each contact into a typed report	Agents
Reconciliation	Decide whether a report opens a new incident or updates an existing one	Code
Incidents	Hold the persistent picture of suspected incidents	Memory
Dispatch	Plan against the incidents and act on the trucks	Agent

Course progression

Here’s how your agent gets built, session by session. If you get lost, come back here and look it up (or ask your agent!):

Session	What you build
Plan, build, review	The report and incident stores: pure-code CRUD memory, built with spec-driven development and PR review.
Skills, tools, and MCPs	Connect the game over MCP and play a round through Claude.
Subagents and evaluation	Fan subagents over the raw contacts to extract typed reports, then turn the accepted labels into Day-2 eval fixtures.
Agentic loop	The task-agnostic agent loop - the walking skeleton every agent in the kit runs on.
Stage 1: dispatcher	Configure the loop into the dispatcher against perfect structured reports, one incident per report.
Stage 2: intake	Put the extraction into production: turn imperfect natural-language contacts into typed reports.
Stage 3: reconciliation	Reconcile duplicates instead of opening a new incident for every report.
Stage 4: replanning	Handle contradictions, corrections, belief revision, and replanning.
Finale	Run the challenge scenario from first contact to terminal state without human intervention.

What counts

The game reports casualties, buildings lost, and runtime tokens separately. There is no single composite score: a cheap agent that misses people is not good, and an accurate agent that spends without bound is not finished.

Warning: This is a difficult simulation. It is not always possible to solve every map without losses.

The game guide describes the simulation, while the API guide documents its typed control surface.