Datasets:

graphnav-anonymous
/

GraphNav

---
license: cc-by-4.0
task_categories:
  - visual-question-answering
  - robotics
tags:
  - spatial-reasoning
  - navigation
  - vision-language-models
  - benchmark
  - cognitive-graph
size_categories:
  - 10K<n<100K
---
# GraphNav: Benchmarking Spatial Cognitive Graph Reasoning in Vision-Language Models

## Overview

GraphNav is a controlled benchmark designed to evaluate spatial cognitive-graph reasoning in vision-language models (VLMs) # GraphNav: Benchmarking Spatial Cognitive Graph Reasoning in Vision-Language Models

## Overview

GraphNav is a controlled benchmark designed to evaluate spatial cognitive-graph reasoning in vision-language models (VLMs) by isolating high-level topological reasoning from execution-level confounds. The benchmark comprises **420 procedurally generated 3D maze environments** and **37,443 navigation paths** across three navigation tasks.

- **Paper**: Submitted to NeurIPS 2026 Evaluations and Datasets Track
- **License**: CC BY 4.0

## Tasks

| Task | Description |
|------|-------------|
| Repeated Navigation | Reproduce a previously explored path in the original direction |
| Reversed Navigation | Travel the same path in the opposite direction |
| Shortcut Discovery | Find the shortest path using partially observed topology |

## Confound Isolation

GraphNav isolates three execution-level confounds that entangle prior benchmarks:

| Confound | Isolation Strategy |
|----------|-------------------|
| Vision-Action Alignment | Four visual annotation conditions (C1–C4) |
| Visual Place Recognition | Distinctive 3D landmarks at every key node (127 unique models) |
| Distance-Angle Estimation | Discrete graph-node movement (no continuous metric estimation) |

## Dataset Structure

```
graphnav-dataset/
├── mazes/                              # 420 maze layout definitions (.txt)
│   ├── Maze_5x5_D0_T4_J2+0.txt
│   ├── Maze_7x7_D1_T6_J3+1.txt
│   ├── ...
│   └── Maze_17x17_*.txt
├── paths/                              # 37,443 navigation paths (.jsonl)
│   ├── repeated/
│   ├── reversed/
│   └── shortcut/
├── images/                             # Rendered observation images
│   ├── maze_nodes_noLabel/             # C1: Unlabeled
│   │   ├── 5x5/
│   │   ├── 7x7/
│   │   ├── 9x9/
│   │   ├── 11x11/
│   │   └── 13x13/
│   ├── maze_nodes_Arrow/               # C2: Arrow annotations (←, ↑, →)
│   │   ├── 5x5/
│   │   ├── 7x7/
│   │   ├── 9x9/
│   │   ├── 11x11/
│   │   └── 13x13/
│   ├── maze_nodes_LFR/                 # C3: Semantic letter annotations (L, F, R)
│   │   ├── 5x5/
│   │   ├── 7x7/
│   │   ├── 9x9/
│   │   ├── 11x11/
│   │   └── 13x13/
│   └── maze_nodes_Num/                 # C4: Numeric annotations (1, 2, 3)
│       ├── 5x5/
│       ├── 7x7/
│       ├── 9x9/
│       ├── 11x11/
│       └── 13x13/
└── README.md
```

## Maze Format (.txt)

Each maze is defined as a text file on a discrete S × S grid (S ∈ {5, 7, 9, 11, 13, 15, 17}).

**Naming convention**: `Maze_{S}x{S}_D{density}_T{topology}_J{junctions}+{loops}.txt`

Example (`Maze_5x5_D0_T4_J2+0.txt`):

```
// Maze Grid: 5x5
// Name: Maze_5x5_D0_T4_J2+0
// 0=Wall, 1=Path
0 1 1 1 1
0 1 0 0 1
0 1 1 1 1
0 1 0 0 1
0 1 1 1 1
```

- `0` = Wall
- `1` = Path (navigable)
- Lines starting with `//` are metadata comments (grid size, maze name, legend)

## Path Format (.jsonl)

Navigation paths are stored in JSONL format (one JSON object per line). Each record contains:

```json
{
  "maze_name": "Maze_5x5_D0_T4_J2+0",
  "episode_id": 1,
  "explore_path_len_target": 5,
  "explore_path": [[1,4], [4,4], [4,2], [1,2], [1,0]],
  "explore_arrivals": [null, 1, 2, 3, 2],
  "start_idx": 0,
  "goal_idx": 3,
  "start": [1, 4],
  "goal": [1, 2],
  "explore_subpath": [[1,4], [4,4], [4,2], [1,2]],
  "ideal_path": [[1,4], [1,2]],
  "explore_len_steps": 3,
  "ideal_len_steps": 1,
  "junctions_on_ideal": 0,
  "constraints": {
    "state_space": "key_nodes_only",
    "observed_graph": "full_explore_path",
    "visibility": "LFR",
    "min_gap": 2,
    "min_savings": 1,
    "min_junctions_on_ideal": 1,
    "ideal_is_global_shortest_on_key_graph": true,
    "ideal_has_junction_deg_ge_3_on_key_graph": true,
    "junction_include_endpoints": false
  }
}
```

### Field Descriptions

| Field | Type | Description |
|-------|------|-------------|
| `maze_name` | string | Identifier linking to the corresponding maze `.txt` file |
| `episode_id` | int | Unique episode index within the maze |
| `explore_path_len_target` | int | Target length for the exploration path |
| `explore_path` | list[list[int]] | Full sequence of key nodes visited during exploration (row, col) |
| `explore_arrivals` | list[int\|null] | Arrival direction at each node (0=N, 1=E, 2=S, 3=W; null for start) |
| `start_idx` | int | Index into `explore_path` for the navigation start node |
| `goal_idx` | int | Index into `explore_path` for the navigation goal node |
| `start` | list[int] | Start node coordinates (row, col) |
| `goal` | list[int] | Goal node coordinates (row, col) |
| `explore_subpath` | list[list[int]] | Subsegment of `explore_path` from `start_idx` to `goal_idx` |
| `ideal_path` | list[list[int]] | Ground-truth optimal path from start to goal |
| `explore_len_steps` | int | Number of steps in the explore subpath |
| `ideal_len_steps` | int | Number of steps in the ideal path |
| `junctions_on_ideal` | int | Number of junction nodes along the ideal path |
| `constraints` | object | Generation constraints and validation flags (see below) |

### Constraints Object

| Field | Description |
|-------|-------------|
| `state_space` | Movement restricted to key nodes only |
| `observed_graph` | Graph scope used for path planning |
| `visibility` | Visual annotation condition |
| `min_gap` | Minimum index gap between start and goal on explore path |
| `min_savings` | Minimum step savings of ideal path vs. explore subpath |
| `min_junctions_on_ideal` | Minimum junctions required on ideal path |
| `ideal_is_global_shortest_on_key_graph` | Whether ideal path is globally shortest |
| `ideal_has_junction_deg_ge_3_on_key_graph` | Whether ideal path passes through a degree ≥ 3 junction |
| `junction_include_endpoints` | Whether endpoints count as junctions |

## Image Conditions

Each observation is a stitched triple-perspective image (left, front, right views) rendered from the agent's current position. Four annotation conditions control the level of vision-action alignment scaffolding:

| Condition | Folder | Annotation | Description |
|-----------|--------|------------|-------------|
| C1 | `maze_nodes_noLabel/` | None | Raw triple-perspective image |
| C2 | `maze_nodes_Arrow/` | ← ↑ → | Arrow overlays on each sub-view |
| C3 | `maze_nodes_LFR/` | L F R | Semantic letter labels on each sub-view |
| C4 | `maze_nodes_Num/` | 1 2 3 | Numeric labels on each sub-view |

Each condition folder contains 5 maze sizes (5×5, 7×7, 9×9, 11×11, 13×13), with rendered node-level observation images for the corresponding mazes.

## Benchmark Statistics

| Property | Value |
|----------|-------|
| Grid sizes | 5, 7, 9, 11, 13, 15, 17 |
| Total mazes | 420 |
| Total paths | 37,443 |
| Paths per maze | ~90 (avg ~30 per task) |
| Landmark catalog | 127 unique 3D models |
| Action space | {left, front, right} |
| Navigation tasks | 3 (repeated, reversed, shortcut) |

## Environment Generation

Mazes are procedurally generated using the Unity engine with a modified Prim-style randomized carving algorithm. The generation process controls:

- **Branching factor**: Interpolates between high branching and long corridors
- **Loop and junction control**: Bounded loop probability and junction counts
- **Landmark placement**: Distinct 3D objects from a 127-model catalog at every salient node
- **Geometric constraints**: Step-length, straight-corridor caps, wall-thickness minima

The Unity project for environment generation is available in the accompanying code repository.

## How to Use

### 1. Loading Maze Definitions

The maze grid loader skips comment lines (`//`, `#`) and retains only pure 0/1 rows. The grid is stored as `grid[x][y]` with the y-axis inverted (y increases upward in world coordinates).

```python
def load_maze_grid(grid_path):
    """Load maze grid from .txt file.
    Returns: grid (2D list, grid[x][y]), width, height
    """
    with open(grid_path, "r", encoding="utf-8") as f:
        lines = f.readlines()
    data_lines = []
    for line in lines:
        line = line.strip()
        if not line or line.startswith("//") or line.startswith("#"):
            continue
        toks = line.split()
        if toks and all(t in ("0", "1") for t in toks):
            data_lines.append(toks)
    height = len(data_lines)
    width = len(data_lines[0])
    # grid[x][y], y increases upward (row 0 in file = top = max y)
    grid = [[0] * height for _ in range(width)]
    for row_idx in range(height):
        for x in range(width):
            grid_y = height - 1 - row_idx
            grid[x][grid_y] = int(data_lines[row_idx][x])
    return grid, width, height
grid, w, h = load_maze_grid("mazes/Maze_5x5_D0_T4_J2+0.txt")
print(f"Grid size: {w}x{h}")
# grid[x][y] == 1 means navigable path; 0 means wall
```

### 2. Loading Navigation Episodes

Episodes are stored in JSONL format (one JSON object per line). Each file may contain multiple episodes for the same maze.

```python
import json
def load_episodes(filepath):
    """Load all episodes from a .jsonl file."""
    episodes = []
    with open(filepath, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if line:
                episodes.append(json.loads(line))
    return episodes
episodes = load_episodes("paths/shortcut/Maze_5x5_D0_T4_J2+0.jsonl")
print(f"Loaded {len(episodes)} episodes")
ep = episodes[0]
print(f"Maze: {ep['maze_name']}")
print(f"Start: {ep['start']}, Goal: {ep['goal']}")
print(f"Explore path ({ep['explore_path_len_target']} nodes): {ep['explore_path']}")
print(f"Ideal path ({ep['ideal_len_steps']} steps): {ep['ideal_path']}")
```

### 3. Running VLM Evaluation

The full evaluation code (environment, agent, prompt construction, metrics) is available in the accompanying code repository:

> **Code**: [https://anonymous.4open.science/r/paper-code-submission-2026-5FF4](https://anonymous.4open.science/r/paper-code-submission-2026-5FF4)

The codebase is organized as:

- `toolKit_core.py` / `toolKit_core_forward.py` — shared utilities: maze environment, navigation graph, image indexing, episode execution, metrics
- `maze_NUM_*.py` — C4 (numeric 1-2-3) agent and prompt
- `maze_LFR_*.py` — C3 (letter L-F-R) agent and prompt
- `maze_Arrow_*.py` — C2 (arrow ←↑→) agent and prompt
- `maze_noLabel_*.py` — C1 (unlabeled) agent and prompt

Quick start:

```python
import toolKit_core as core
# Configure variant (num / lfr / arrow / nolabel)
core.configure("num")
# Load maze environment
env = core.MazeEnv("Maze_5x5_D0_T4_J2+0")
# Load episodes
episodes = core.load_episodes_for_maze("Maze_5x5_D0_T4_J2+0", core.PRECOMPUTED_EPISODES_ROOT)
```

See the code repository README for detailed setup instructions, API configuration, and full reproduction steps.

### 4. Navigation Loop

At each step, the VLM agent receives a multimodal prompt containing:

1. **Task instructions** — navigation goal description
2. **Few-shot examples** — wall vs. path image examples
3. **Exploration experience** — sequence of triple-perspective images with action labels from the learned path
4. **History** — images and actions taken so far in the current trip
5. **Destination** — overview image of the goal node
6. **Current observation** — triple-perspective stitched image at the current position

The agent outputs a single action token (`1`/`2`/`3` for C4, `L`/`F`/`R` for C3, `←`/`↑`/`→` for C2, or `left`/`front`/`right` for C1), which is mapped to a relative direction and executed in the maze environment. Invalid actions trigger a retry with explicit feedback.

### 5. Metrics

| Metric | Task | Description |
|--------|------|-------------|
| **SR** (Success Rate) | All | Fraction of episodes where the agent reaches the goal within the step budget |
| **PFS** (Path Fidelity Score) | Repeated Nav., Reversed Nav. | Overlap of directed edges between actual and ideal paths, normalized by actual path length; 0 if goal not reached |
| **SPL** (Success weighted by Path Length) | Shortcut Discovery | Ratio of ideal to actual path length, scaled by success indicator |
| **DPS** (Directional Progress Score) | Shortcut Discovery | Average cosine similarity between movement vectors and goal vectors across all steps |


## License

This dataset is released under the [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) license.

	---
	license: cc-by-4.0
	task_categories:
	- visual-question-answering
	- robotics
	tags:
	- spatial-reasoning
	- navigation
	- vision-language-models
	- benchmark
	- cognitive-graph
	size_categories:
	- 10K<n<100K
	---

	# GraphNav: Benchmarking Spatial Cognitive Graph Reasoning in Vision-Language Models

	## Overview

	GraphNav is a controlled benchmark designed to evaluate spatial cognitive-graph reasoning in vision-language models (VLMs) # GraphNav: Benchmarking Spatial Cognitive Graph Reasoning in Vision-Language Models

	## Overview

	GraphNav is a controlled benchmark designed to evaluate spatial cognitive-graph reasoning in vision-language models (VLMs) by isolating high-level topological reasoning from execution-level confounds. The benchmark comprises 420 procedurally generated 3D maze environments and 37,443 navigation paths across three navigation tasks.

	- Paper: Submitted to NeurIPS 2026 Evaluations and Datasets Track
	- License: CC BY 4.0

	## Tasks

	\| Task \| Description \|
	\|------\|-------------\|
	\| Repeated Navigation \| Reproduce a previously explored path in the original direction \|
	\| Reversed Navigation \| Travel the same path in the opposite direction \|
	\| Shortcut Discovery \| Find the shortest path using partially observed topology \|

	## Confound Isolation

	GraphNav isolates three execution-level confounds that entangle prior benchmarks:

	\| Confound \| Isolation Strategy \|
	\|----------\|-------------------\|
	\| Vision-Action Alignment \| Four visual annotation conditions (C1–C4) \|
	\| Visual Place Recognition \| Distinctive 3D landmarks at every key node (127 unique models) \|
	\| Distance-Angle Estimation \| Discrete graph-node movement (no continuous metric estimation) \|

	## Dataset Structure

	```
	graphnav-dataset/
	├── mazes/ # 420 maze layout definitions (.txt)
	│ ├── Maze_5x5_D0_T4_J2+0.txt
	│ ├── Maze_7x7_D1_T6_J3+1.txt
	│ ├── ...
	│ └── Maze_17x17_*.txt
	├── paths/ # 37,443 navigation paths (.jsonl)
	│ ├── repeated/
	│ ├── reversed/
	│ └── shortcut/
	├── images/ # Rendered observation images
	│ ├── maze_nodes_noLabel/ # C1: Unlabeled
	│ │ ├── 5x5/
	│ │ ├── 7x7/
	│ │ ├── 9x9/
	│ │ ├── 11x11/
	│ │ └── 13x13/
	│ ├── maze_nodes_Arrow/ # C2: Arrow annotations (←, ↑, →)
	│ │ ├── 5x5/
	│ │ ├── 7x7/
	│ │ ├── 9x9/
	│ │ ├── 11x11/
	│ │ └── 13x13/
	│ ├── maze_nodes_LFR/ # C3: Semantic letter annotations (L, F, R)
	│ │ ├── 5x5/
	│ │ ├── 7x7/
	│ │ ├── 9x9/
	│ │ ├── 11x11/
	│ │ └── 13x13/
	│ └── maze_nodes_Num/ # C4: Numeric annotations (1, 2, 3)
	│ ├── 5x5/
	│ ├── 7x7/
	│ ├── 9x9/
	│ ├── 11x11/
	│ └── 13x13/
	└── README.md
	```

	## Maze Format (.txt)

	Each maze is defined as a text file on a discrete S × S grid (S ∈ {5, 7, 9, 11, 13, 15, 17}).

	Naming convention: `Maze_{S}x{S}_D{density}_T{topology}_J{junctions}+{loops}.txt`

	Example (`Maze_5x5_D0_T4_J2+0.txt`):

	```
	// Maze Grid: 5x5
	// Name: Maze_5x5_D0_T4_J2+0
	// 0=Wall, 1=Path
	0 1 1 1 1
	0 1 0 0 1
	0 1 1 1 1
	0 1 0 0 1
	0 1 1 1 1
	```

	- `0` = Wall
	- `1` = Path (navigable)
	- Lines starting with `//` are metadata comments (grid size, maze name, legend)

	## Path Format (.jsonl)

	Navigation paths are stored in JSONL format (one JSON object per line). Each record contains:

	```json
	{
	"maze_name": "Maze_5x5_D0_T4_J2+0",
	"episode_id": 1,
	"explore_path_len_target": 5,
	"explore_path": [[1,4], [4,4], [4,2], [1,2], [1,0]],
	"explore_arrivals": [null, 1, 2, 3, 2],
	"start_idx": 0,
	"goal_idx": 3,
	"start": [1, 4],
	"goal": [1, 2],
	"explore_subpath": [[1,4], [4,4], [4,2], [1,2]],
	"ideal_path": [[1,4], [1,2]],
	"explore_len_steps": 3,
	"ideal_len_steps": 1,
	"junctions_on_ideal": 0,
	"constraints": {
	"state_space": "key_nodes_only",
	"observed_graph": "full_explore_path",
	"visibility": "LFR",
	"min_gap": 2,
	"min_savings": 1,
	"min_junctions_on_ideal": 1,
	"ideal_is_global_shortest_on_key_graph": true,
	"ideal_has_junction_deg_ge_3_on_key_graph": true,
	"junction_include_endpoints": false
	}
	}
	```

	### Field Descriptions

	\| Field \| Type \| Description \|
	\|-------\|------\|-------------\|
	\| `maze_name` \| string \| Identifier linking to the corresponding maze `.txt` file \|
	\| `episode_id` \| int \| Unique episode index within the maze \|
	\| `explore_path_len_target` \| int \| Target length for the exploration path \|
	\| `explore_path` \| list[list[int]] \| Full sequence of key nodes visited during exploration (row, col) \|
	\| `explore_arrivals` \| list[int\\|null] \| Arrival direction at each node (0=N, 1=E, 2=S, 3=W; null for start) \|
	\| `start_idx` \| int \| Index into `explore_path` for the navigation start node \|
	\| `goal_idx` \| int \| Index into `explore_path` for the navigation goal node \|
	\| `start` \| list[int] \| Start node coordinates (row, col) \|
	\| `goal` \| list[int] \| Goal node coordinates (row, col) \|
	\| `explore_subpath` \| list[list[int]] \| Subsegment of `explore_path` from `start_idx` to `goal_idx` \|
	\| `ideal_path` \| list[list[int]] \| Ground-truth optimal path from start to goal \|
	\| `explore_len_steps` \| int \| Number of steps in the explore subpath \|
	\| `ideal_len_steps` \| int \| Number of steps in the ideal path \|
	\| `junctions_on_ideal` \| int \| Number of junction nodes along the ideal path \|
	\| `constraints` \| object \| Generation constraints and validation flags (see below) \|

	### Constraints Object

	\| Field \| Description \|
	\|-------\|-------------\|
	\| `state_space` \| Movement restricted to key nodes only \|
	\| `observed_graph` \| Graph scope used for path planning \|
	\| `visibility` \| Visual annotation condition \|
	\| `min_gap` \| Minimum index gap between start and goal on explore path \|
	\| `min_savings` \| Minimum step savings of ideal path vs. explore subpath \|
	\| `min_junctions_on_ideal` \| Minimum junctions required on ideal path \|
	\| `ideal_is_global_shortest_on_key_graph` \| Whether ideal path is globally shortest \|
	\| `ideal_has_junction_deg_ge_3_on_key_graph` \| Whether ideal path passes through a degree ≥ 3 junction \|
	\| `junction_include_endpoints` \| Whether endpoints count as junctions \|

	## Image Conditions

	Each observation is a stitched triple-perspective image (left, front, right views) rendered from the agent's current position. Four annotation conditions control the level of vision-action alignment scaffolding:

	\| Condition \| Folder \| Annotation \| Description \|
	\|-----------\|--------\|------------\|-------------\|
	\| C1 \| `maze_nodes_noLabel/` \| None \| Raw triple-perspective image \|
	\| C2 \| `maze_nodes_Arrow/` \| ← ↑ → \| Arrow overlays on each sub-view \|
	\| C3 \| `maze_nodes_LFR/` \| L F R \| Semantic letter labels on each sub-view \|
	\| C4 \| `maze_nodes_Num/` \| 1 2 3 \| Numeric labels on each sub-view \|

	Each condition folder contains 5 maze sizes (5×5, 7×7, 9×9, 11×11, 13×13), with rendered node-level observation images for the corresponding mazes.

	## Benchmark Statistics

	\| Property \| Value \|
	\|----------\|-------\|
	\| Grid sizes \| 5, 7, 9, 11, 13, 15, 17 \|
	\| Total mazes \| 420 \|
	\| Total paths \| 37,443 \|
	\| Paths per maze \| ~90 (avg ~30 per task) \|
	\| Landmark catalog \| 127 unique 3D models \|
	\| Action space \| {left, front, right} \|
	\| Navigation tasks \| 3 (repeated, reversed, shortcut) \|

	## Environment Generation

	Mazes are procedurally generated using the Unity engine with a modified Prim-style randomized carving algorithm. The generation process controls:

	- Branching factor: Interpolates between high branching and long corridors
	- Loop and junction control: Bounded loop probability and junction counts
	- Landmark placement: Distinct 3D objects from a 127-model catalog at every salient node
	- Geometric constraints: Step-length, straight-corridor caps, wall-thickness minima

	The Unity project for environment generation is available in the accompanying code repository.

	## How to Use

	### 1. Loading Maze Definitions

	The maze grid loader skips comment lines (`//`, `#`) and retains only pure 0/1 rows. The grid is stored as `grid[x][y]` with the y-axis inverted (y increases upward in world coordinates).

	```python
	def load_maze_grid(grid_path):
	"""Load maze grid from .txt file.
	Returns: grid (2D list, grid[x][y]), width, height
	"""
	with open(grid_path, "r", encoding="utf-8") as f:
	lines = f.readlines()

	data_lines = []
	for line in lines:
	line = line.strip()
	if not line or line.startswith("//") or line.startswith("#"):
	continue
	toks = line.split()
	if toks and all(t in ("0", "1") for t in toks):
	data_lines.append(toks)

	height = len(data_lines)
	width = len(data_lines[0])

	# grid[x][y], y increases upward (row 0 in file = top = max y)
	grid = [[0] * height for _ in range(width)]
	for row_idx in range(height):
	for x in range(width):
	grid_y = height - 1 - row_idx
	grid[x][grid_y] = int(data_lines[row_idx][x])

	return grid, width, height

	grid, w, h = load_maze_grid("mazes/Maze_5x5_D0_T4_J2+0.txt")
	print(f"Grid size: {w}x{h}")
	# grid[x][y] == 1 means navigable path; 0 means wall
	```

	### 2. Loading Navigation Episodes

	Episodes are stored in JSONL format (one JSON object per line). Each file may contain multiple episodes for the same maze.

	```python
	import json

	def load_episodes(filepath):
	"""Load all episodes from a .jsonl file."""
	episodes = []
	with open(filepath, "r", encoding="utf-8") as f:
	for line in f:
	line = line.strip()
	if line:
	episodes.append(json.loads(line))
	return episodes

	episodes = load_episodes("paths/shortcut/Maze_5x5_D0_T4_J2+0.jsonl")
	print(f"Loaded {len(episodes)} episodes")

	ep = episodes[0]
	print(f"Maze: {ep['maze_name']}")
	print(f"Start: {ep['start']}, Goal: {ep['goal']}")
	print(f"Explore path ({ep['explore_path_len_target']} nodes): {ep['explore_path']}")
	print(f"Ideal path ({ep['ideal_len_steps']} steps): {ep['ideal_path']}")
	```

	### 3. Running VLM Evaluation

	The full evaluation code (environment, agent, prompt construction, metrics) is available in the accompanying code repository:

	> Code: [https://anonymous.4open.science/r/paper-code-submission-2026-5FF4](https://anonymous.4open.science/r/paper-code-submission-2026-5FF4)

	The codebase is organized as:

	- `toolKit_core.py` / `toolKit_core_forward.py` — shared utilities: maze environment, navigation graph, image indexing, episode execution, metrics
	- `maze_NUM_*.py` — C4 (numeric 1-2-3) agent and prompt
	- `maze_LFR_*.py` — C3 (letter L-F-R) agent and prompt
	- `maze_Arrow_*.py` — C2 (arrow ←↑→) agent and prompt
	- `maze_noLabel_*.py` — C1 (unlabeled) agent and prompt

	Quick start:

	```python
	import toolKit_core as core

	# Configure variant (num / lfr / arrow / nolabel)
	core.configure("num")

	# Load maze environment
	env = core.MazeEnv("Maze_5x5_D0_T4_J2+0")

	# Load episodes
	episodes = core.load_episodes_for_maze("Maze_5x5_D0_T4_J2+0", core.PRECOMPUTED_EPISODES_ROOT)
	```

	See the code repository README for detailed setup instructions, API configuration, and full reproduction steps.

	### 4. Navigation Loop

	At each step, the VLM agent receives a multimodal prompt containing:

	1. Task instructions — navigation goal description
	2. Few-shot examples — wall vs. path image examples
	3. Exploration experience — sequence of triple-perspective images with action labels from the learned path
	4. History — images and actions taken so far in the current trip
	5. Destination — overview image of the goal node
	6. Current observation — triple-perspective stitched image at the current position

	The agent outputs a single action token (`1`/`2`/`3` for C4, `L`/`F`/`R` for C3, `←`/`↑`/`→` for C2, or `left`/`front`/`right` for C1), which is mapped to a relative direction and executed in the maze environment. Invalid actions trigger a retry with explicit feedback.

	### 5. Metrics

	\| Metric \| Task \| Description \|
	\|--------\|------\|-------------\|
	\| SR (Success Rate) \| All \| Fraction of episodes where the agent reaches the goal within the step budget \|
	\| PFS (Path Fidelity Score) \| Repeated Nav., Reversed Nav. \| Overlap of directed edges between actual and ideal paths, normalized by actual path length; 0 if goal not reached \|
	\| SPL (Success weighted by Path Length) \| Shortcut Discovery \| Ratio of ideal to actual path length, scaled by success indicator \|
	\| DPS (Directional Progress Score) \| Shortcut Discovery \| Average cosine similarity between movement vectors and goal vectors across all steps \|


	## License

	This dataset is released under the [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) license.