Customizing Entity Leash Position and Lead Attachment

Making an entity interact with a lead is split between the behavior pack and the resource pack. The behavior pack controls whether a player can attach a lead at all, how far the entity can wander before the rope pulls it back, and when the rope snaps. The resource pack controls where the visual rope renders on the model.

When the client renders a leashed entity, it inspects the active geometry for a bone locator specifically named `lead`. If that locator is present, the end of the rope is pinned to its world position and follows the parent bone's animations. If no `lead` locator exists in the geometry, the renderer falls back to a hardcoded offset calculated from the entity's collision box dimensions.

Before you can test the visual position of a lead, the entity must accept being leashed. Add the `minecraft:leashable` component to your behavior pack entity definition. Without this component, holding a lead and interacting with the entity does nothing.

This component takes distance thresholds measured in blocks. As the entity moves away from the player or fence knot holding the lead, it crosses the soft distance (where it starts pathfinding back), the hard distance (where it is physically pulled or rubber-banded), and finally the max distance (where the lead breaks and drops as an item).

{
  "format_version": "1.20.0",
  "minecraft:entity": {
    "description": {
      "identifier": "my_addon:pack_mule",
      "is_spawnable": true,
      "is_summonable": true
    },
    "components": {
      "minecraft:collision_box": {
        "width": 0.9,
        "height": 1.4
      },
      "minecraft:leashable": {
        "soft_distance": 4.0,
        "hard_distance": 6.0,
        "max_distance": 10.0,
        "can_be_stolen": false
      }
    }
  }
}

To move the visual attachment point of the rope, open your entity's `.geo.json` file in your resource pack (or edit the model inside Blockbench). You need to add a locator named `lead` to the bone where the collar, bridle, or harness sits—usually the `neck` or `head` bone.

In Bedrock geometry, a locator is a named point in model space attached to a specific bone. Because it is parented to a bone, the locator moves and rotates whenever that bone is animated. Placing the `lead` locator on the `head` bone ensures that when your entity looks around or bends down to graze, the end of the leash moves naturally with its snout or collar.

In the JSON structure, `locators` is an object inside a bone definition. For a simple position offset, assign an array of three numbers `[x, y, z]` representing model-space coordinates (16 units equals 1 block, matching cube origin coordinates).

{
  "format_version": "1.12.0",
  "minecraft:geometry": [
    {
      "description": {
        "identifier": "geometry.pack_mule",
        "texture_width": 64,
        "texture_height": 64,
        "visible_bounds_width": 2,
        "visible_bounds_height": 2,
        "visible_bounds_offset": [0, 1, 0]
      },
      "bones": [
        {
          "name": "body",
          "pivot": [0, 12, 0],
          "cubes": [
            {
              "origin": [-5, 8, -8],
              "size": [10, 8, 16],
              "uv": [0, 0]
            }
          ]
        },
        {
          "name": "neck",
          "parent": "body",
          "pivot": [0, 14, -7],
          "cubes": [
            {
              "origin": [-2, 14, -9],
              "size": [4, 7, 4],
              "uv": [0, 24]
            }
          ],
          "locators": {
            "lead": [0, 18, -9]
          }
        }
      ]
    }
  ]
}

Most custom entities only need the single `lead` locator. However, some vanilla entities with complex rigging or specific tether interactions define numbered locators or use multiple bones. For standard custom mobs leached by a player or tied to a fence, stick to the exact lowercase name `lead`.

If you are modeling in Blockbench, you can add this locator using the Locator tool while the target bone (`neck` or `head`) is selected in the outliner. Rename the created locator to `lead` and drag it in the viewport to sit right on the surface of the mesh where a collar ring would be. When exported as a Bedrock Entity Geometry (`1.12.0` or newer), Blockbench writes the `locators` object onto that bone automatically.

Note that while locators in `1.12.0` geometry also support an expanded object syntax with `offset` and `rotation` keys (mostly used for particle emitters or item attachment), the leash renderer only cares about the world position of the point. The simple `[x, y, z]` array format is sufficient for `lead`.

{
  "format_version": "1.12.0",
  "minecraft:geometry": [
    {
      "description": {
        "identifier": "geometry.pack_mule_alt",
        "texture_width": 64,
        "texture_height": 64
      },
      "bones": [
        {
          "name": "head",
          "pivot": [0, 20, -8],
          "locators": {
            "lead": {
              "offset": [0, 21, -11],
              "rotation": [0, 0, 0]
            }
          }
        }
      ]
    }
  ]
}

Because the `lead` locator lives inside the geometry hierarchy, any transformation applied to its parent bone (or ancestor bones like `root` and `body`) will move the leash attachment point on screen. If an animation translates the `head` bone downward by 6 units, the leash moves downward by 6 units.

Similarly, if your behavior pack scales the entity—such as using the `minecraft:scale` component for a baby variant—the model and its locators scale together. You do not need a separate geometry file or separate locator coordinates for baby variants unless the baby uses a completely different model layout.

Applies to all modern Bedrock versions using geometry format 1.12.0 and behavior format 1.16.0 or newer. No experimental toggles are required.

Read out of the game itself, so the ids match the version you are building for.