Example Slice — Walkthrough (Pygame Asset Design & Development)
Status: ACTIVE (illustration) Agent: opencode/ext-agent (sandshrew) Timestamp UTC: 2026-05-11T22:35:00Z Claim: illustration | 2026-05-11T22:30:00Z Session: Turn-by-turn walkthrough of the 36-hex grid with 3 units, nested UI flow
Cast
| Unit | Role | Position | Config |
|---|---|---|---|
| Rif | Designer | Hex 16 | deepseek-v4 / opencode |
| Echo | Developer | Hex 22 | kimi-k2.6 / hermes |
| Sherpa | Researcher | Hex 05 | deepseek-v4 / opencode |
Mission: Design and develop the sprite assets and hex tile map for the LangGraph game surface pygame prototype.
TURN 1 — Player surveys the board, moves Sherpa
Hex Grid (what the player sees)
__ __ __ __ __ __
__/00\__/01\__/02\__/03\__/04\__/05\__ ← Sherpa here (Research)
/06\__/07\__/08\__/09\__/10\__/11\__/12\
\__/13\__/14\__/15\__/16\__/17\__/18\__/ ← Rif here (Design)
/19\__/20\__/21\__/22\__/23\__/24\__/25\ ← Echo here (Develop)
\__/26\__/27\__/28\__/29\__/30\__/31\__/
/32\__/33\__/34\__/35\__/ \__/ \__/ \
\__/ \__/ \__/ \__/ \__/ \__/ \__/
──────────────────────────────────────────────────
TURN 1 | [A] Select [X] Unit [Y] Node
──────────────────────────────────────────────────
D-pad cursor lands on hex 05. Presses A.
Tile Menu (A on hex 05)
┌──────────────────────────────────────────────────────────┐
│ HEX 05 — Research │
│──────────────────────────────────────────────────────────│
│ ▶ Sherpa — Researcher │
│ Status: idle │
│ Config: deepseek-v4 / opencode │
│ │
│ [X] Unit Menu [Y] Node Menu [B] Back │
└──────────────────────────────────────────────────────────┘
Player presses Y to inspect the node itself.
Node Menu (Y)
┌──────────────────────────────────────────────────────────┐
│ NODE: Hex 05 — Research │
│──────────────────────────────────────────────────────────│
│ ▶ Status: OPEN │
│ ▶ Edges: → 00, 01, 06, 11, 12, 04 │
│ ▶ Config: default prompt set, deepseek-v4 │
│──────────────────────────────────────────────────────────│
│ [A] Select [B] Back │
└──────────────────────────────────────────────────────────┘
Player presses B, B to return to grid. Then presses X for Unit Menu.
Unit Menu (X on Sherpa)
┌──────────────────────────────────────────────────────────┐
│ UNIT: Sherpa — Researcher │
│──────────────────────────────────────────────────────────│
│ ▶ Status: idle at Hex 05 │
│ ▶ Config: deepseek-v4 / opencode / [read, write] │
│ ▶ Trail: (empty — starting position) │
│ ▶ Access: mission brief, wiki/langgraph-docs.md │
│──────────────────────────────────────────────────────────│
│ [A] Move Unit [B] Back │
└──────────────────────────────────────────────────────────┘
Player presses A to move Sherpa. D-pad to hex 06. Presses A.
Move Config
┌──────────────────────────────────────────────────────────┐
│ MOVE: Sherpa → Hex 06 (Research) │
│──────────────────────────────────────────────────────────│
│ Config: deepseek-v4 / opencode [Change] │
│ Bring: (nothing to bring yet) │
│ Block: none [Add block] │
│──────────────────────────────────────────────────────────│
│ [A] Confirm Move [B] Cancel │
└──────────────────────────────────────────────────────────┘
Player confirms. The RG sends invoke({action: "move", unit: "sherpa", target: "06"}) to the Pi.
Sherpa's Node Activates
Sherpa arrives at hex 06. The node function runs:
Pi: node_06 activated. Unit: Sherpa. Phase: Research.
Pi: Agent called. Prompt: "Research: what sprite formats and tile dimensions
are optimal for a 640×480 pygame hex grid on RG40XXV?"
Pi: Agent responded. 180 tokens. Latency: 1.4s.
Pi: interrupt() — "Review research output."
Interrupt Prompt (on RG)
┌──────────────────────────────────────────────────────────┐
│ HEX 06 — Sherpa (Research) │
│──────────────────────────────────────────────────────────│
│ Chain of thought: │
│ "RG40XXV runs pygame 2.5.2. Optimal: PNG sprites, │
│ 32×32 or 64×64. Hex tiles should be flat-top, │
│ ~100×87px to fit 6×6 grid. Use sprite sheets for │
│ performance." │
│ │
│ Output summary: │
│ ▶ Sprite format: PNG, 32×32 px │
│ ▶ Tile size: flat-top hex, 100×87 px │
│ ▶ Color depth: RGBA (alpha for transparency) │
│ ▶ Performance: sprite sheets over individual files │
│──────────────────────────────────────────────────────────│
│ [A] Accept [X] Correct [Y] Pull context [B] Back│
└──────────────────────────────────────────────────────────┘
Player reads. Looks good. Presses A.
Node Completes
Sherpa finishes at hex 06. State updated: hex 06 status → completed. Output written to wiki.
TURN 2 — Player moves Rif, notices a problem
Rif (Designer) is at hex 16. Player moves Rif to hex 17. Rif runs: "Design the sprite sheet layout and tile palette."
Rif produces a recommendation. The interrupt prompt shows:
┌──────────────────────────────────────────────────────────┐
│ HEX 17 — Rif (Design) │
│──────────────────────────────────────────────────────────│
│ Recommendation: │
│ "Use 128×128 px sprites. Rich palette with gradients. │
│ Individual PNG files per tile for maximum quality." │
│ │
│ ⚠ Player sees a problem. That's too heavy for RG. │
│──────────────────────────────────────────────────────────│
│ [A] Accept [X] Correct [Y] Pull context │
└──────────────────────────────────────────────────────────┘
Player presses X. A text input appears:
┌──────────────────────────────────────────────────────────┐
│ CORRECTION for Hex 17 │
│──────────────────────────────────────────────────────────│
│ "128px sprites too heavy for RG. Consult Sherpa's │
│ research at Hex 06 — they recommended 32px. │
│ Restructure for RG constraints." │
│──────────────────────────────────────────────────────────│
│ [A] Send [B] Cancel │
└──────────────────────────────────────────────────────────┘
Player types this on the RG (gamepad keyboard or external). Presses A. The correction is appended to node_player_prompts["17"]. Node 17 stays in_progress.
TURN 3 — Player supplies Rif with Sherpa's context
Player wants Rif to see Sherpa's research before re-running. D-pad to hex 06 (Sherpa's completed node). Presses Y.
Node Output (hex 06)
┌──────────────────────────────────────────────────────────┐
│ OUTPUT — Hex 06 (Sherpa) STATUS: DONE │
│──────────────────────────────────────────────────────────│
│ ▶ Sprite format: PNG, 32×32 px [FINAL] │
│ ▶ Tile size: flat-top hex, 100×87 px [FINAL] │
│ ▶ Color depth: RGBA [FINAL] │
│ ▶ Performance: sprite sheets [FINAL] │
│──────────────────────────────────────────────────────────│
│ [A] Zoom in [X] Route to... [B] Back │
└──────────────────────────────────────────────────────────┘
Player presses X. Selects Rif's hex (17) as target.
Route Context
┌──────────────────────────────────────────────────────────┐
│ ROUTE: Hex 06 (Sherpa) → Hex 17 (Rif) │
│──────────────────────────────────────────────────────────│
│ Rif's prompt template: "Design solution for: {task}" │
│──────────────────────────────────────────────────────────│
│ [A] Curate Context │
│ Agent filters Sherpa's research for Rif's design │
│ [X] Point Wholesale │
│ Rif gets full pointer to Sherpa's output │
│ [B] Cancel │
└──────────────────────────────────────────────────────────┘
Player presses A (Curate). A curation agent runs: reads Sherpa's output, reads Rif's prompt template, produces a targeted subset. Writes to routed_context["17"]["from_06"]. Adds to Rif's access list.
TURN 4 — Rif re-runs with corrections + curated context
Player returns to hex 17. Selects Rif. Presses "Re-run" (since node is still in_progress).
Rif activates again. This time it reads:
System prompt:
"Previous reasoning: recommended 128px sprites.
Player noted: '128px too heavy for RG. Consult Sherpa's research.'
Curated context from Sherpa (Hex 06): PNG 32×32, flat-top hex 100×87.
Restructure for RG constraints."
Rif produces new output:
┌──────────────────────────────────────────────────────────┐
│ HEX 17 — Rif (Design) TURN 4 │
│──────────────────────────────────────────────────────────│
│ Revised recommendation: │
│ ▶ Sprites: 32×32 px PNG, sprite sheet │
│ ▶ Tiles: flat-top hex, 100×87 px │
│ ▶ Palette: 16-color indexed (RG constraint) │
│ ▶ Tile count: 7 terrain types × 1 variant each = 7 tiles│
│ ▶ Sprite count: 3 unit icons, 6 UI elements │
│ │
│ ⚠ Previous correction: "128px too heavy" (resolved) │
│──────────────────────────────────────────────────────────│
│ [A] Accept [X] Correct [Y] Pull context │
└──────────────────────────────────────────────────────────┘
Player accepts. Hex 17 → completed. Output written to wiki.
TURN 5 — Echo develops, player checks output
Echo (Developer) is at hex 22. Player moves Echo to hex 23. Echo runs: "Implement the sprite assets per Rif's design spec."
Echo produces a sprite sheet. The interrupt prompt shows the output summary:
┌──────────────────────────────────────────────────────────┐
│ OUTPUT — Hex 23 (Echo) │
│──────────────────────────────────────────────────────────│
│ ▶ assets/sprites/terrain.png [FINAL] │
│ 7 tiles: grass, forest, water, mountain, city, │
│ desert, snow. 32×32 px indexed PNG. │
│ │
│ ▶ assets/sprites/units.png [FINAL] │
│ 3 unit icons. 16×16 px. │
│ │
│ ▶ assets/ui/panel.png [FINAL] │
│ Status bar background. 640×45 px. │
│──────────────────────────────────────────────────────────│
│ [A] Accept [X] Correct [Y] Full page (wiki) │
└──────────────────────────────────────────────────────────┘
Player presses Y. The RG shows: "Full output at: wiki/assets/echo-sprite-sheet.md — open on Mac?" Player says yes. Mac browser opens the wiki page with the full sprite sheet, hex coordinates, and palette table.
THE LOOP SUMMARIZED
Turn start
↓
Player surveys hex grid (D-pad moves cursor)
↓
Presses A on a hex → Tile Menu (unit info + node info)
├── X: Unit Menu → [Status] [Config] [Trail] [Move]
│ └── Move → select destination → Move Config → Confirm → invoke()
└── Y: Node Menu → [Properties] [Output] [Edges]
└── Output → [Zoom in on sections] [Route to other node]
└── Route → [Curate Context] [Point Wholesale]
↓
invoke() fires → LangGraph node runs → agent called → output produced
↓
interrupt() — player sees chain of thought + output summary
├── Accept: node completes, output written to wiki
├── Correct: player types correction → queued for next turn
└── Pull context: player fetches more from access list
↓
State updates → RG re-renders → next turn
Three units, one grid. Each moves independently. Corrections accumulate per-node. Curated context routes between nodes. Output summaries build up across completed hexes. The player drives everything through nested menus — every level is a state read, every action is an invoke().