Container Examples & Demonstrations

Concrete, runnable-in-spirit examples of Asset Core's container shapes—demonstrating deterministic world-state coordination.

0D Balance

A shared pool of compute credits or energy units. Transactions debit or credit a single scalar value—no positions, only quantity.

What this shows

Scalar aggregates with no spatial coordinates
Atomic balance adjustments (debit/credit)
Deterministic replay of transaction history
Multi-agent shared resource pools

Example operations

{
  "operations": [
    {
      "op": "CreateContainer",
      "args": {
        "kind": "Balance",
        "container": "energy_pool"
      }
    },
    {
      "op": "AdjustBalance",
      "args": {
        "container": "energy_pool",
        "class": "energy_unit",
        "delta": -50
      }
    }
  ]
}

This creates a Balance container called “energy_pool” and adjusts the energy_unit class by -50, reducing the balance from 100 to 50 units.

Diagram legend: before = 100 units, after = 50 units in energy_pool.

Use a 0D balance when only “how much” matters, not “where” it is held.

Deterministic guarantee: Identical sequences yield identical results.

Agent scenario: An LLM agent managing compute credits for a cluster. Agent tool calls:

check_balance() → query current credits
reserve_credits(job_id, amount) → atomic deduction
release_credits(job_id) → refund on job completion

Asset Core guarantees no double-spend, no negative balances, and a full audit trail of every credit transaction.

0D Slots

An entity exposes 8 tool slots. Tools like a camera or gripper occupy exactly one slot; slots have no geometry—just labeled positions.

What this shows

Discrete positions without geometric relationships
Tool/equipment management with slot exclusivity
Deterministic equipment state
Semantic positioning (not spatial coordinates)

Example operations

{
  "operations": [
    {
      "op": "CreateContainer",
      "args": {
        "kind": { "Slots": { "count": 8 } },
        "container": "robot_tools"
      }
    },
    {
      "op": "EquipInstanceInSlot",
      "args": {
        "container": "robot_tools",
        "slot_index": 3,
        "instance": "camera_head"
      }
    }
  ]
}

This creates a Slots container with 8 slots called “robot_tools” and equips a camera_head instance in slot 3.

Diagram legend: slot 3 holds camera_head.

Use slots when you need mutually exclusive positions with labels, but no spatial geometry.

Deterministic guarantee: Identical sequences produce identical slot configurations.

Agent scenario: An LLM agent controlling a robot with 8 tool slots. Agent tool calls:

list_equipped_tools() → query current equipment
equip_tool(slot_id, tool_name) → atomic slot assignment
swap_tools(slot_a, slot_b) → transactional exchange

Asset Core enforces slot exclusivity—no phantom tools, no double-equip, and full provenance of every equipment change.

1D Grid: Linear Conveyor

A conveyor lane with positions 1..5. Agents place and move packages along a single axis; two items can’t occupy the same position.

What this shows

Linear spatial semantics (single-axis positioning)
Collision detection and position exclusivity
Sequential move operations
Deterministic placement and move ordering

Example operations

{
  "operations": [
    {
      "op": "CreateContainer",
      "args": {
        "kind": {
          "Grid": {
            "capacity": 5,
            "grid_width": null
          }
        },
        "container": "conveyor"
      }
    },
    {
      "op": "PlaceInstanceOnGrid",
      "args": {
        "container": "conveyor",
        "position": { "index": 3 },
        "instance": "package_42"
      }
    }
  ]
}

This creates a 1D Grid container with 5 positions called “conveyor” and places package_42 at position 3.

Diagram legend: P42 marks package_42 at position 3.

Use a 1D grid when order along a single lane matters and collisions must be prevented.

Deterministic guarantee: Identical sequences yield identical results.

Agent scenario: An LLM agent managing a conveyor belt. Agent tool calls:

get_item_position(item_id) → query location on belt
move_item(item_id, target_position) → collision-safe movement
remove_item(item_id) → atomic removal from belt

Asset Core prevents double-occupancy, tracks item order, and enables perfect replay of conveyor operations.

1D Continuous: Precision Rail

A calibrated rail with millimeter resolution. A robot carriage moves along a continuous axis using fixed-point coordinates.

What this shows

Fixed-point coordinates with deterministic rounding
Bounds-checked placement along a single axis
Continuous collision checks for overlapping spans
Commit/replay semantics identical to discrete containers

Example operations

{
  "operations": [
    {
      "op": "CreateContainer",
      "args": {
        "kind": {
          "ContinuousLine1d": {
            "min_x": 0,
            "max_x": 200000,
            "quantization_inv": 1000
          }
        },
        "container": "rail"
      }
    },
    {
      "op": "PlaceInstanceInContinuous1d",
      "args": {
        "container": "rail",
        "coord": { "x": 25000 },
        "instance": "carriage_A"
      }
    },
    {
      "op": "MoveInstanceWithinContinuous1d",
      "args": {
        "container": "rail",
        "instance": "carriage_A",
        "to_coord": { "x": 158750 }
      }
    }
  ]
}

This creates a ContinuousLine1d container called “rail” and moves carriage_A to x=158.750 (quantization_inv=1000).

Diagram legend: C = carriage_A.

Use a 1D continuous line when real-world distances along a single axis must be preserved.

Deterministic guarantee: Identical sequences yield identical results.

Agent scenario: An LLM agent controlling a linear rail. Agent tool calls:

get_carriage_position(carriage_id) → query current coordinate
move_carriage(carriage_id, target_x) → collision-safe movement
reserve_span(start_x, end_x) → ensure exclusive travel window

Asset Core enforces deterministic placement, prevents overlap, and provides exact replay of rail motion.

2D Grid: Warehouse Floor

A small warehouse grid (5×5). Robots and packages occupy discrete coordinates; committed moves are serialized to prevent collisions.

What this shows

Two-dimensional spatial semantics (x, y coordinates)
Multi-entity collision detection
Coordinate-based placement and movement
Authoritative grid state for multi-agent coordination

Example operations

{
  "operations": [
    {
      "op": "CreateContainer",
      "args": {
        "kind": {
          "Grid": {
            "capacity": 25,
            "grid_width": 5
          }
        },
        "container": "warehouse"
      }
    },
    {
      "op": "PlaceInstanceOnGrid",
      "args": {
        "container": "warehouse",
        "position": { "x": 1, "y": 4 },
        "instance": "robot_A"
      }
    },
    {
      "op": "PlaceInstanceOnGrid",
      "args": {
        "container": "warehouse",
        "position": { "x": 2, "y": 4 },
        "instance": "package_12"
      }
    }
  ]
}

This creates a 2D Grid container (5×5) called “warehouse” and places robot_A at (1,4) and package_12 at (2,4).

Diagram legend: R = robot_A, P = package_12.

Use a 2D grid when agents need shared coordinates, neighborhood awareness, and collision-safe movement.

Deterministic guarantee: Identical sequences produce identical world states.

Agent scenario: Multiple LLM agents navigating a shared warehouse floor. Agent tool calls:

get_robot_position(robot_id) → query current coordinates
plan_path(start, goal) → collision-aware pathfinding
move_robot(robot_id, target_coords) → atomic, collision-safe movement

Asset Core provides authoritative spatial state—no ghost positions, no collisions, and full coordination history across all agents.

2D Continuous: Robot Workcell

A bounded workcell for pick-and-place robotics. Placements use fixed-point x/y coordinates with deterministic rotation in millidegrees.

What this shows

Fixed-point x/y coordinates with explicit quantization
Oriented-rectangle collision checks (OBB)
Bounds-checked placements, moves, and rotations
Deterministic replay of multi-agent motion plans

Example operations

{
  "operations": [
    {
      "op": "CreateContainer",
      "args": {
        "kind": {
          "ContinuousGrid2d": {
            "min_x": 0,
            "min_y": 0,
            "max_x": 200000,
            "max_y": 120000,
            "quantization_inv": 1000,
            "bucket_cell_size": 10000
          }
        },
        "container": "workcell"
      }
    },
    {
      "op": "PlaceInstanceInContinuous2d",
      "args": {
        "container": "workcell",
        "coord": { "x": 25000, "y": 40000 },
        "rotation": 0,
        "instance": "gripper_A"
      }
    },
    {
      "op": "PlaceInstanceInContinuous2d",
      "args": {
        "container": "workcell",
        "coord": { "x": 110000, "y": 30000 },
        "rotation": 90000,
        "instance": "part_17"
      }
    },
    {
      "op": "MoveInstanceWithinContinuous2d",
      "args": {
        "container": "workcell",
        "instance": "gripper_A",
        "to_coord": { "x": 90000, "y": 80000 }
      }
    }
  ]
}

This creates a ContinuousGrid2d workcell, places gripper_A at (25.000, 40.000), places part_17 at (110.000, 30.000), and moves the gripper toward the target.

Diagram legend: G = gripper_A, P = part_17.

Use a 2D continuous container when physical coordinates and rotation must be preserved.

Deterministic guarantee: Identical sequences produce identical world states.

Agent scenario: A robot planner coordinating picks in a shared workcell. Agent tool calls:

preflight_commit(pick_plan) → validate the sequence without mutation
commit(pick_plan) → execute once preflight succeeds
read_workcell_region(bounds) → query nearby placements for collision checks

Asset Core ensures preflight and commit stay in lockstep while preserving a deterministic audit trail.

Universal Transfer: Cross-Dimensional Operations

Asset Core’s operations work consistently across container types. The same grammar applies whether transferring between balances, slots, or grids—demonstrating the universal operation model.

What this shows

Unified operation semantics across dimensions
Cross-container state transitions
Consistent commit log for multi-container workflows
Composable world-state transformations

Example: Balance → 2D Grid Transfer

{
  "operations": [
    {
      "op": "CreateContainer",
      "args": {
        "kind": "Balance",
        "container": "parts_pool"
      }
    },
    {
      "op": "CreateContainer",
      "args": {
        "kind": {
          "Grid": {
            "capacity": 25,
            "grid_width": 5
          }
        },
        "container": "assembly_floor"
      }
    },
    {
      "op": "AdjustBalance",
      "args": {
        "container": "parts_pool",
        "class": "widget",
        "delta": -1
      }
    },
    {
      "op": "PlaceInstanceOnGrid",
      "args": {
        "container": "assembly_floor",
        "position": { "x": 2, "y": 3 },
        "instance": "widget#0001"
      }
    }
  ]
}

This converts a quantity from a 0D balance into a placed item on a 2D grid—same operation grammar, different container types.

Same verbs (adjust, place, transfer) across container types; deterministic ordering ties both changes to one commit history.

Agent scenario: An LLM agent transferring parts from a pool (0D balance) to assembly positions (2D grid). Agent tool calls:

check_parts_available() → query balance
reserve_and_place(part_type, grid_coords) → atomic cross-container operation

Asset Core commits both changes atomically—no phantom inventory, no lost parts, and a unified audit trail across container types.

Learn More

For technical details, see Basics for architecture and container types, or the Docs for deeper technical documentation.