Datasets:

cagataydev
/

strands-isaaclab-tictactoe

A Franka arm in NVIDIA Isaac Lab plays tic-tac-toe. A Strands Agent picks the moves through four game tools, the arm picks each token from a tray and puts it on the board, and every move is recorded as a LeRobot v3.0 episode with strands-robots' DatasetRecorder.

Game g00: the agent plays X against a minimax opponent and draws. Left: overhead camera, right: front camera, 4× speed. Full-speed mp4 · final board · agent transcript.


games	10: 6 agent vs minimax (agent alternates X/O), 4 agent vs agent. All 10 draws.
episodes / frames	90 / 29,070 at 30 fps (1 episode = 1 pick-and-place move, ~10.8 s)
cameras	`observation.images.overhead` and `observation.images.front`, 320×240 RTX, fixed
`observation.state`	31-D = 9 Franka joint pos + end-effector pos (3) + gripper command (1) + board one-hot (9 cells × X/O = 18)
`action`	9-D joint position targets (7 arm + 2 fingers) from the scripted DiffIK pick-and-place controller
task strings	13, e.g. `"place X in the center cell"`, `"place O in the top-left cell"`
placements	90 / 90 (100 %), all first attempt · placement error mean 1.78 mm, max 4.2 mm
vision check	overhead-camera board vs simulator: 1 disagreement in 100+ board reads (a stale frame right after reset, see Limitations)
checks	strands `verify_dataset` ok · `LeRobotDataset` load ok · video decode ok · NaN/inf = 0 · Hub round-trip ok

Results

game	mode	agent plays	result	placements	error mean / max (mm)	vision disagreements	wall (s)
g00	agent vs minimax	X	draw	9/9	1.78 / 4.2	1	162.9
g01	agent vs minimax	O	draw	9/9	1.76 / 3.5	0	151.7
g02	agent vs minimax	X	draw	9/9	1.78 / 4.2	0	157.9
g03	agent vs minimax	O	draw	9/9	1.76 / 3.5	0	152.8
g04	agent vs minimax	X	draw	9/9	1.78 / 4.2	0	159.6
g05	agent vs minimax	O	draw	9/9	1.82 / 3.5	0	152.6
g06	agent vs agent	X + O	draw	9/9	1.78 / 4.2	0	191.5
g07	agent vs agent	X + O	draw	9/9	1.78 / 4.2	0	190.3
g08	agent vs agent	X + O	draw	9/9	1.78 / 4.2	0	192.4
g09	agent vs agent	X + O	draw	9/9	1.78 / 4.2	0	189.6

About 105 s of each game is the robot (9 moves × ~11.7 s) and the rest is model time. Total ≈ 28 min on one L40S. Per-game logs are in games/: game.json (summary + every LLM turn), moves.jsonl (per-move placement error, grasp, vision board), transcript.md (the full agent conversation with tool calls).

How it works

 strands venv                                            Isaac Lab venv (strands_robots on PYTHONPATH)
 ┌──────────────────────────────────────┐  JSON lines   ┌─────────────────────────────────────────────┐
 │ Agent(tools=[get_board, place_mark,   │  over TCP     │ ttt_server.py (Isaac Lab InteractiveScene)   │
 │              reset_game, render_board])│ ───────────▶ │  Franka HIGH_PD + 3×3 board + 5 X / 5 O tokens│
 │ opponent: minimax or a 2nd Agent      │ ◀─────────── │  DiffIK pick→place, overhead + front cameras  │
 │ referee: turn order, legality         │               │  strands DatasetRecorder: 1 move = 1 episode  │
 └──────────────────────────────────────┘               └─────────────────────────────────────────────┘

The game tools are plain Strands @tool functions (from examples/ttt_tools.py, trimmed):

from strands import Agent, tool
from strands.models import BedrockModel

@tool
def get_board() -> dict:
    """Look at the board: simulator truth + the overhead camera's view, whose turn it is, game status."""
    r = game.state()                      # server: sim token poses -> cells, and colour segmentation on the overhead camera
    return {"status": "success", "content": [{"text": ascii_board(r["board"]) + f"\ncamera agrees with sim: {r['agree']}"}]}

@tool
def place_mark(cell: str) -> dict:
    """Have the robot pick one of your tokens from the tray and place it on a cell ("center", "top-left", 1-9)."""
    r = game.place(mark, parse_cell(cell), by=name)   # server: DiffIK pick -> place, records one DatasetRecorder episode
    return {"status": "success", "content": [{"text": f"placed {mark} in {cell} (error {1000 * r['place_err_m']:.1f} mm)"}]}

agent = Agent(model=BedrockModel(model_id="global.anthropic.claude-opus-5-5"),
              tools=[get_board, place_mark, reset_game, render_board],
              system_prompt="You are playing tic-tac-toe ... call place_mark exactly once per turn ...")
agent("Let's play tic-tac-toe. You are X. Place your marks with the robot. You go first.")

On the server side each move is written through strands' recorder:

from strands_robots.dataset_recorder import DatasetRecorder

rec = DatasetRecorder.create(
    repo_id="cagataydev/strands-isaaclab-tictactoe", fps=30, robot_type="franka_panda",
    joint_names=JOINTS, action_names=ACTIONS,                     # 9 Franka joints / 9 joint targets
    camera_keys=["overhead", "front"], camera_dims={"overhead": (240, 320), "front": (240, 320)},
    extra_state_specs=[("ee_pos", ["x", "y", "z"]), ("gripper_cmd", ["close"]),
                       ("board", [f"{cell}.{m}" for cell in CELL_NAMES for m in "XO"])],
    task="play tic-tac-toe", root="runs/prod1/ds", use_videos=True)
for obs, act in move_frames:                      # every physics/render frame of one pick-and-place
    rec.add_frame(obs, act, task="place X in the center cell", camera_keys=["overhead", "front"])
rec.save_episode()                                # one episode per move; rec.finalize() at the end of the run

Reproduce

# Isaac Lab in its OWN venv (its pins clash with strands; strands never imports it)
uv venv --python 3.12 ~/il && uv pip install --python ~/il/bin/python --prerelease=allow \
  --index https://pypi.nvidia.com --index-strategy unsafe-best-match "isaaclab[rsl-rl,isaacsim]==3.0.0rc1" lerobot==0.6.1
export OMNI_KIT_ACCEPT_EULA=YES          # you accept the NVIDIA Omniverse / Isaac Sim EULA yourself
git clone https://github.com/strands-labs/robots && export STRANDS=$PWD/robots
# 1. start the Isaac Lab game server (logs to a file, protocol on a TCP port)
cd examples && PYTHONPATH=$STRANDS ~/il/bin/python ttt_server.py --port 8765 --log server.log &
# 2. play from the strands venv (needs Bedrock credentials; set STRANDS_MODEL_ID)
PYTHONPATH=$STRANDS python play_games.py --port 8765 --schedule agent_vs_minimax:6,agent_vs_agent:4 --alternate \
  --video all --out runs/prod1 --record runs/prod1/ds --repo_id cagataydev/strands-isaaclab-tictactoe

ttt_server.py --mock runs the whole agent/tool/vision/recording stack on CPU with a numpy stand-in for Isaac Lab.

Use it

from lerobot.datasets.lerobot_dataset import LeRobotDataset

ds = LeRobotDataset("cagataydev/strands-isaaclab-tictactoe")
print(ds.num_episodes, ds.num_frames, ds.fps)          # 90 29070 30
f = ds[0]; f["observation.state"].shape, f["action"].shape, f["observation.images.overhead"].shape, f["task"]
# (31,) (9,) (3, 240, 320) 'place X in the center cell'

Check it with strands:

from huggingface_hub import snapshot_download
from strands_robots.verify_dataset import verify_dataset

root = snapshot_download("cagataydev/strands-isaaclab-tictactoe", repo_type="dataset")
report = verify_dataset(root, expected=90)
assert report["ok"], report["problems"]

The language-conditioned task strings make this a small goal-conditioned pick-and-place set (13 goals), e.g. for behaviour cloning with strands' lerobot_local train_policy provider (not run for this card):

from strands_robots.tools.train_policy import train_policy
train_policy(action="train", provider="lerobot_local", dataset_repo_id="cagataydev/strands-isaaclab-tictactoe",
             output_dir="runs/smolvla_ttt", steps=20000, batch_size=32, extra={"policy_type": "smolvla"})

Provenance

strands-robots: main with strands-labs/robots#4227 (DatasetRecorder, verify_dataset); recorded from feat/isaaclab-trainer @ fa66fc68
Strands Agents with Amazon Bedrock, model global.anthropic.claude-opus-5-5; opponent: exact minimax
Isaac Lab 3.0.0rc1 · Isaac Sim 6.1.0.0 · PhysX · FRANKA_PANDA_HIGH_PD_CFG · DifferentialIK (DLS) · lerobot 0.6.1
GPU: 1× NVIDIA L40S (46 GB) · recorded 2026-09-29, run prod1

Limitations

Simulation only. No real Franka; no sim-to-real claims.
The robot motion is scripted, not learned: the agent chooses where, a DiffIK pick-and-place controller does how. The dataset is expert demonstrations of that controller, labelled by the agent's chosen goal.
Little variety in games. Minimax is deterministic and the model plays nearly the same way every time, so the 10 games end on only 3 distinct final boards (all agent-vs-agent games and every agent-as-X game repeat the same sequence). Moves and frames differ slightly between games; the goals do not. Perfect play from both sides always draws.
Vision: the one disagreement was a stale RTX frame read right after a reset (the overhead camera still showed the previous game's O). The agent noticed it, trusted the simulator and said so. Fix: render a few frames after reset.
Isaac Lab runs in a separate process because its pins (Python 3.12, torch, warp) clash with the strands venv; strands has no built-in tool for step-by-step control of an Isaac Lab scene yet.

License

license: other: our generated data under CC-BY-4.0, plus NVIDIA notices. See LICENSE.md. The recorded trajectories, camera video, GIF/PNG and transcripts are user-generated content made with Isaac Sim (NVIDIA Omniverse License Agreement §2.1 allows distributing it); the table, board and tokens are procedural primitives. No NVIDIA Content is redistributed: the Franka Panda USD comes from NVIDIA's asset server under your own EULA acceptance. Code in examples/ is Apache-2.0 (as strands-robots) on top of Isaac Lab (BSD-3-Clause). Running Isaac Sim requires accepting the NVIDIA EULA.

Downloads last month: 110