diff --git a/demos/baba-is-ai/README.md b/demos/baba-is-ai/README.md
new file mode 100644
index 0000000..6f43ff4
--- /dev/null
+++ b/demos/baba-is-ai/README.md
@@ -0,0 +1,125 @@
+# Baba Is AI
+
+An LLM agent plays a simplified "Baba Is You" puzzle game where the rules of the world are physical word-block objects on a grid. The agent must push word-blocks to change or break rules in order to reach the goal.
+
+## The Experiment
+
+### Background
+
+Based on findings from the [BALROG benchmark](https://arxiv.org/abs/2411.13543) (Benchmarking Agentic LLM and VLM Reasoning On Games), which found that **all tested LLMs score near 0% on Baba Is You** despite understanding the rules perfectly when quizzed in isolation.
+
+### The Knowing-Doing Gap
+
+LLMs can explain that "rules are pushable objects" and "you need to rearrange word-blocks to change rules." But when given a spatial grid and asked to actually execute moves to push specific blocks in specific directions, they fail consistently. They *know* what to do but *cannot do* it.
+
+### What This Demo Tests
+
+Can an LLM agent, given a text observation of a 9x9 grid, figure out that it needs to:
+1. Navigate to the right word-block
+2. Push it in the right direction
+3. Verify the rule changed
+4. Navigate through the now-passable area to win
+
+This is **meta-rule discovery** -- the agent doesn't just follow rules, it manipulates them.
+
+### Why It Matters for ABM
+
+Agent-based models traditionally have fixed rules. This demo shows agents operating in a world where **the rules themselves are agents** (word-blocks) that can be moved. The rule engine is pure NetLogo ABM; the decision-making is LLM. Together they create a system where rules are emergent from the spatial arrangement of objects.
+
+## Prerequisites
+
+1. **Ollama** running locally with `qwen2.5:7b` pulled:
+   ```bash
+   ollama pull qwen2.5:7b
+   ```
+2. **NetLogo 7.0.3** with the LLM extension JAR installed
+3. Built extension: run `./build.sh` from the extension root if needed
+
+## How to Run
+
+1. Open `baba-is-ai.nlogox` in NetLogo 7.0.3
+2. Select a level from the chooser
+3. Click **Setup** to initialize
+4. Click **Go** to let the LLM agent play autonomously, or **Step** for one move at a time
+5. Toggle **show-observations?** to see the text observation sent to the LLM each turn
+6. Watch the **Active Rules** monitor update as word-blocks are pushed
+
+## Levels
+
+### Level 1: Navigate (baseline)
+```
+Rules: BABA IS YOU, FLAG IS WIN
+Layout: baba on the left, flag on the right, clear path
+Solution: Walk right to the flag (~7 moves)
+Expected: Most LLMs solve this consistently
+```
+
+### Level 2: Break the Wall (medium)
+```
+Rules: BABA IS YOU, WALL IS STOP, FLAG IS WIN
+Layout: Wall column blocking the path to the flag
+Solution: Navigate to the STOP word-block, push it away to break
+          "WALL IS STOP", then walk through walls to the flag
+Expected: Some LLMs occasionally solve this; most get stuck
+```
+
+### Level 3: Push and Rearrange (hard)
+```
+Rules: BABA IS YOU, ROCK IS PUSH, WALL IS STOP, FLAG IS WIN
+Layout: Rocks near the WALL IS STOP rule, wall column, flag behind walls
+Solution: Navigate around rocks, push STOP away, walk through walls
+Expected: Very rarely solved -- demonstrates the knowing-doing gap
+```
+
+## Swapping Providers
+
+Edit `config` to try different LLM providers:
+
+```
+# OpenAI
+provider=openai
+model=gpt-4o-mini
+api_key=YOUR_KEY_HERE
+
+# Anthropic
+provider=anthropic
+model=claude-sonnet-4-20250514
+api_key=YOUR_KEY_HERE
+
+# Gemini
+provider=gemini
+model=gemini-2.0-flash
+api_key=YOUR_KEY_HERE
+```
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `baba-is-ai.nlogox` | Main NetLogo model with rule engine, levels, and LLM integration |
+| `config` | LLM provider configuration (defaults to local Ollama) |
+| `action-template.yaml` | Documents the prompt format (not used at runtime -- `llm:choose` builds its own prompt) |
+| `README.md` | This file |
+
+## How It Works
+
+### Rule Engine
+Three consecutive word-blocks in a horizontal or vertical line form a rule: `[NOUN] IS [PROPERTY]`. The engine scans all possible 3-tuples every tick and rebuilds the active rule set.
+
+### Push System
+Word-blocks are **always pushable**. Other entities (rocks, walls) are pushable only if they have the PUSH property. Push chains propagate: pushing a block into another pushable block pushes both.
+
+### LLM Integration
+Each tick, the agent receives a text observation including the grid layout, active rules, adjacent cell descriptions, and feedback from the last action. It chooses from `["up", "down", "left", "right"]` via `llm:choose`. History accumulates across ticks so the agent can learn from failed moves.
+
+## Extension Points
+
+- **New properties**: Add DEFEAT (touching kills baba), SINK (object + baba both destroyed), MELT/HOT combos
+- **Multiple YOU entities**: What if two things are YOU and must coordinate?
+- **Procedural level generation**: Random placement of word-blocks and obstacles
+- **Rule construction**: Levels where the agent must *build* a rule, not just break one
+
+## Reference
+
+- BALROG paper: [arXiv 2411.13543](https://arxiv.org/abs/2411.13543)
+- Baba Is You (original game): [hempuli.com/baba](https://hempuli.com/baba/)
diff --git a/demos/baba-is-ai/action-template.yaml b/demos/baba-is-ai/action-template.yaml
new file mode 100644
index 0000000..ed40e18
--- /dev/null
+++ b/demos/baba-is-ai/action-template.yaml
@@ -0,0 +1,20 @@
+system: |
+  You are playing Baba Is AI, a puzzle game where the rules of the world are
+  physical word-block objects on a grid. Three consecutive word-blocks in a row
+  or column form a rule: [NOUN] IS [PROPERTY]. For example, "BABA IS YOU" means
+  you control the baba character, "WALL IS STOP" means walls block movement,
+  and "FLAG IS WIN" means reaching a flag wins the level.
+
+  CRITICAL INSIGHT: You can PUSH word-blocks to change or break rules. If you
+  push the STOP block away from "WALL IS STOP", walls become passable. Rules
+  are not fixed -- they are objects you can physically manipulate.
+
+  Your goal: reach an entity that has the WIN property.
+
+  Respond with exactly one of: up, down, left, right
+
+template: |
+  {observation}
+
+  Think about which rules you need to change to reach the goal.
+  Choose your move.
diff --git a/demos/baba-is-ai/baba-is-ai.nlogox b/demos/baba-is-ai/baba-is-ai.nlogox
new file mode 100644
index 0000000..f368501
--- /dev/null
+++ b/demos/baba-is-ai/baba-is-ai.nlogox
@@ -0,0 +1,819 @@
+<?xml version="1.0" encoding="utf-8"?>
+<model version="NetLogo 7.0.3" snapToGrid="false">
+  <code><![CDATA[
+;; ABOUTME: Baba Is AI — LLM agent solves puzzles by pushing word-blocks that define the rules
+;; ABOUTME: Demonstrates the knowing-doing gap: LLMs understand rules but struggle with spatial execution
+
+extensions [llm]
+
+breed [word-blocks word-block]
+breed [babas baba]
+breed [walls wall]
+breed [rocks rock]
+breed [flags flag]
+
+word-blocks-own [ word-text word-type ]  ;; type: "noun" "verb" "property"
+babas-own [ last-action last-action-succeeded? ]
+
+globals [
+  active-rules
+  total-moves
+  total-llm-calls
+  llm-config-loaded?
+  game-state
+  move-history
+]
+
+;; ============================================================
+;; SETUP
+;; ============================================================
+
+to setup
+  clear-all
+  set active-rules []
+  set total-moves 0
+  set total-llm-calls 0
+  set game-state "playing"
+  set move-history []
+
+  carefully [
+    llm:load-config "config"
+    set llm-config-loaded? true
+  ] [
+    output-print (word "Config error: " error-message)
+    set llm-config-loaded? false
+  ]
+
+  resize-world 0 8 0 8
+  set-patch-size 40.0
+  ask patches [ set pcolor 1 ]
+
+  let level-num read-from-string (substring level-choice 0 1)
+  if level-num = 1 [ setup-level-1 ]
+  if level-num = 2 [ setup-level-2 ]
+  if level-num = 3 [ setup-level-3 ]
+
+  ;; Inject game-aware system message so the LLM knows what it's playing
+  ask babas [
+    llm:set-history (list
+      (list "system" (word
+        "You are playing Baba Is AI, a puzzle game on a 9x9 grid (0-8). "
+        "You move one square per turn: up, down, left, or right. "
+        "Word-blocks on the grid form rules when 3 align horizontally: [NOUN] IS [PROPERTY]. "
+        "Example: WALL IS STOP means walls block movement. FLAG IS WIN means touching the flag wins. "
+        "PUSHING: When you walk into a word-block, it slides one square in your direction. "
+        "If you push a word-block out of a 3-block alignment, that rule BREAKS. "
+        "STRATEGY: If walls block your path to the flag, find the [STOP] word-block on the grid. "
+        "Walk to it and push it away from [WALL] and [IS] — this breaks WALL IS STOP and walls become passable. "
+        "Then walk through the walls to reach the flag. "
+        "PRIORITY: 1) If blocked by walls, go break the STOP block first. 2) Then head to the flag."
+      ))
+    )
+  ]
+
+  evaluate-rules
+  reset-ticks
+end
+
+;; ============================================================
+;; LEVEL LAYOUTS
+;; ============================================================
+
+to setup-level-1
+  ;; Level 1: Navigate — walk right to the flag
+  ;; Word-blocks: BABA IS YOU (top), FLAG IS WIN (bottom)
+  ;; Rules at top row — safe from accidental pushing
+  create-word-block-at 0 8 "BABA" "noun"
+  create-word-block-at 1 8 "IS"   "verb"
+  create-word-block-at 2 8 "YOU"  "property"
+
+  create-word-block-at 6 8 "FLAG" "noun"
+  create-word-block-at 7 8 "IS"   "verb"
+  create-word-block-at 8 8 "WIN"  "property"
+
+  create-babas 1 [
+    setxy 1 4
+    set shape "person"
+    set color white
+    set size 0.9
+    set last-action ""
+    set last-action-succeeded? true
+  ]
+
+  create-flags 1 [
+    setxy 7 4
+    set shape "flag"
+    set color yellow
+    set size 0.9
+  ]
+end
+
+to setup-level-2
+  ;; Level 2: Break the Wall — push STOP away to pass through walls
+  ;; Rules at top — safe from accidental pushing
+  create-word-block-at 0 8 "BABA" "noun"
+  create-word-block-at 1 8 "IS"   "verb"
+  create-word-block-at 2 8 "YOU"  "property"
+
+  create-word-block-at 6 8 "FLAG" "noun"
+  create-word-block-at 7 8 "IS"   "verb"
+  create-word-block-at 8 8 "WIN"  "property"
+
+  ;; WALL IS STOP — the rule to break. STOP is at (3,4), pushable right
+  create-word-block-at 1 4 "WALL" "noun"
+  create-word-block-at 2 4 "IS"   "verb"
+  create-word-block-at 3 4 "STOP" "property"
+
+  create-babas 1 [
+    setxy 1 6
+    set shape "person"
+    set color white
+    set size 0.9
+    set last-action ""
+    set last-action-succeeded? true
+  ]
+
+  ;; Wall column at x=5, floor to row 7 — no way around
+  let wall-y 0
+  while [wall-y <= 7] [
+    create-walls 1 [
+      setxy 5 wall-y
+      set shape "square"
+      set color gray
+      set size 0.9
+    ]
+    set wall-y wall-y + 1
+  ]
+
+  create-flags 1 [
+    setxy 7 4
+    set shape "flag"
+    set color yellow
+    set size 0.9
+  ]
+end
+
+to setup-level-3
+  ;; Level 3: Push and Rearrange — navigate around rocks, break wall rule, reach flag
+  create-word-block-at 0 8 "BABA" "noun"
+  create-word-block-at 1 8 "IS"   "verb"
+  create-word-block-at 2 8 "YOU"  "property"
+
+  create-word-block-at 0 5 "ROCK" "noun"
+  create-word-block-at 1 5 "IS"   "verb"
+  create-word-block-at 2 5 "PUSH" "property"
+
+  create-word-block-at 0 2 "WALL" "noun"
+  create-word-block-at 1 2 "IS"   "verb"
+  create-word-block-at 2 2 "STOP" "property"
+
+  create-word-block-at 6 8 "FLAG" "noun"
+  create-word-block-at 7 8 "IS"   "verb"
+  create-word-block-at 8 8 "WIN"  "property"
+
+  create-babas 1 [
+    setxy 0 7
+    set shape "person"
+    set color white
+    set size 0.9
+    set last-action ""
+    set last-action-succeeded? true
+  ]
+
+  ;; Rocks near the WALL IS STOP rule
+  create-rocks 1 [ setxy 3 3  set shape "circle" set color orange set size 0.9 ]
+  create-rocks 1 [ setxy 3 2  set shape "circle" set color orange set size 0.9 ]
+
+  ;; Wall column at x=5, floor to row 7 — no way around
+  let wall-y 0
+  while [wall-y <= 7] [
+    create-walls 1 [
+      setxy 5 wall-y
+      set shape "square"
+      set color gray
+      set size 0.9
+    ]
+    set wall-y wall-y + 1
+  ]
+
+  create-flags 1 [
+    setxy 8 4
+    set shape "flag"
+    set color yellow
+    set size 0.9
+  ]
+end
+
+;; ============================================================
+;; WORD-BLOCK HELPER
+;; ============================================================
+
+to create-word-block-at [ px py txt typ ]
+  create-word-blocks 1 [
+    setxy px py
+    set word-text txt
+    set word-type typ
+    set shape "square"
+    set size 0.9
+    set label word-text
+    set label-color black
+
+    ;; Color by type
+    if typ = "noun"     [ set color magenta ]
+    if typ = "verb"     [ set color white ]
+    if typ = "property" [ set color yellow ]
+  ]
+end
+
+;; ============================================================
+;; RULE ENGINE
+;; ============================================================
+
+to evaluate-rules
+  set active-rules []
+
+  ;; Scan horizontal 3-tuples
+  let px min-pxcor
+  while [px <= max-pxcor - 2] [
+    let py min-pycor
+    while [py <= max-pycor] [
+      let wb1 word-block-at px py
+      let wb2 word-block-at (px + 1) py
+      let wb3 word-block-at (px + 2) py
+      if wb1 != nobody and wb2 != nobody and wb3 != nobody [
+        if [word-type] of wb1 = "noun" and [word-text] of wb2 = "IS" and [word-type] of wb3 = "property" [
+          let rule-str (word [word-text] of wb1 " IS " [word-text] of wb3)
+          if not member? rule-str active-rules [
+            set active-rules lput rule-str active-rules
+          ]
+        ]
+      ]
+      set py py + 1
+    ]
+    set px px + 1
+  ]
+
+  ;; Scan vertical 3-tuples
+  set px min-pxcor
+  while [px <= max-pxcor] [
+    let py min-pycor
+    while [py <= max-pycor - 2] [
+      let wb1 word-block-at px py
+      let wb2 word-block-at px (py + 1)
+      let wb3 word-block-at px (py + 2)
+      if wb1 != nobody and wb2 != nobody and wb3 != nobody [
+        if [word-type] of wb1 = "noun" and [word-text] of wb2 = "IS" and [word-type] of wb3 = "property" [
+          let rule-str (word [word-text] of wb1 " IS " [word-text] of wb3)
+          if not member? rule-str active-rules [
+            set active-rules lput rule-str active-rules
+          ]
+        ]
+      ]
+      set py py + 1
+    ]
+    set px px + 1
+  ]
+end
+
+to-report word-block-at [ px py ]
+  let target patch px py
+  if target = nobody [ report nobody ]
+  let wbs (word-blocks-on target)
+  ifelse any? wbs [ report one-of wbs ] [ report nobody ]
+end
+
+to-report has-property? [ noun-name prop-name ]
+  let rule-str (word noun-name " IS " prop-name)
+  report member? rule-str active-rules
+end
+
+;; ============================================================
+;; MOVEMENT & PUSH SYSTEM
+;; ============================================================
+
+to try-move [ direction ]
+  ;; Calculate delta from direction string
+  let move-dx 0
+  let move-dy 0
+  if direction = "up"    [ set move-dy 1 ]
+  if direction = "down"  [ set move-dy -1 ]
+  if direction = "left"  [ set move-dx -1 ]
+  if direction = "right" [ set move-dx 1 ]
+
+  let target-x xcor + move-dx
+  let target-y ycor + move-dy
+
+  ;; Boundary check
+  let target-patch patch target-x target-y
+  if target-patch = nobody [
+    set last-action-succeeded? false
+    stop
+  ]
+
+  ;; Check for STOP entities on target
+  if is-blocked? target-patch [
+    set last-action-succeeded? false
+    stop
+  ]
+
+  ;; Check for pushable entities on target
+  let pushables get-pushables-on target-patch
+  if any? pushables [
+    let push-ok try-push-chain target-patch move-dx move-dy
+    if not push-ok [
+      set last-action-succeeded? false
+      stop
+    ]
+  ]
+
+  ;; Move baba
+  setxy target-x target-y
+  set last-action-succeeded? true
+end
+
+to-report is-blocked? [ target-patch ]
+  ;; Check if any breed with STOP property is on the patch
+  if has-property? "WALL" "STOP" and any? (walls-on target-patch) [ report true ]
+  if has-property? "ROCK" "STOP" and any? (rocks-on target-patch) [ report true ]
+  if has-property? "BABA" "STOP" and any? (other babas-on target-patch) [ report true ]
+  report false
+end
+
+to-report get-pushables-on [ target-patch ]
+  ;; Word-blocks are always pushable
+  let result (word-blocks-on target-patch)
+
+  ;; Breed entities with PUSH property
+  if has-property? "ROCK" "PUSH" [
+    set result (turtle-set result (rocks-on target-patch))
+  ]
+  if has-property? "WALL" "PUSH" [
+    set result (turtle-set result (walls-on target-patch))
+  ]
+  if has-property? "FLAG" "PUSH" [
+    set result (turtle-set result (flags-on target-patch))
+  ]
+
+  report result
+end
+
+to-report try-push-chain [ start-patch move-dx move-dy ]
+  ;; Check if we can push everything in the chain
+  let current-patch start-patch
+  let chain-patches (list)
+
+  ;; Walk the chain
+  let keep-going true
+  while [keep-going] [
+    let pushables-here get-pushables-on current-patch
+    ifelse any? pushables-here [
+      set chain-patches lput current-patch chain-patches
+      let next-x ([pxcor] of current-patch) + move-dx
+      let next-y ([pycor] of current-patch) + move-dy
+      set current-patch patch next-x next-y
+      if current-patch = nobody [ report false ]  ;; boundary
+      if is-blocked? current-patch [ report false ] ;; STOP entity
+    ] [
+      set keep-going false
+    ]
+  ]
+
+  ;; Push from the end of the chain backward
+  let chain-idx (length chain-patches) - 1
+  while [chain-idx >= 0] [
+    let p item chain-idx chain-patches
+    let pushables-here get-pushables-on p
+    ask pushables-here [
+      setxy (xcor + move-dx) (ycor + move-dy)
+    ]
+    set chain-idx chain-idx - 1
+  ]
+
+  report true
+end
+
+;; ============================================================
+;; LLM INTEGRATION
+;; ============================================================
+
+to go
+  if game-state != "playing" [ stop ]
+  if not llm-config-loaded? [
+    output-print "LLM config not loaded. Check config file."
+    set game-state "error"
+    stop
+  ]
+
+  ask babas [
+    if has-property? "BABA" "YOU" [
+      ;; Cap history to system message + last 10 exchanges to avoid token bloat
+      let hist llm:history
+      if length hist > 21 [
+        llm:set-history (sentence (list item 0 hist) (sublist hist (length hist - 20) (length hist)))
+      ]
+
+      let obs build-observation
+      if show-observations? [ output-print obs ]
+
+      set total-llm-calls total-llm-calls + 1
+      carefully [
+        let action llm:choose obs ["up" "down" "left" "right"]
+        set last-action action
+        set total-moves total-moves + 1
+        set move-history lput action move-history
+        try-move action
+      ] [
+        ;; Rate limit: wait and retry next tick
+        if member? "rate_limit" error-message [
+          output-print "Rate limited — waiting 2s..."
+          wait 2
+          stop
+        ]
+        output-print (word "LLM error: " error-message)
+      ]
+    ]
+  ]
+
+  evaluate-rules
+  check-win-defeat
+  tick
+end
+
+to step
+  go
+end
+
+;; ============================================================
+;; OBSERVATION BUILDER
+;; ============================================================
+
+to-report build-observation
+  let obs ""
+  let baba-x [xcor] of one-of babas
+  let baba-y [ycor] of one-of babas
+
+  ;; Find flag position
+  let flag-x -1
+  let flag-y -1
+  if any? flags [
+    set flag-x [xcor] of one-of flags
+    set flag-y [ycor] of one-of flags
+  ]
+
+  ;; Game context
+  set obs (word obs "BABA IS AI PUZZLE GAME\n")
+  set obs (word obs "You control BABA. Move up/down/left/right on a 9x9 grid.\n")
+  set obs (word obs "Word-blocks like [BABA] [IS] [YOU] form rules when aligned.\n")
+  set obs (word obs "You can push word-blocks by walking into them.\n\n")
+
+  ;; Position and goal with explicit direction
+  set obs (word obs "Your position: (" baba-x ", " baba-y ")\n")
+  if flag-x >= 0 [
+    set obs (word obs "FLAG position: (" flag-x ", " flag-y ")\n")
+    ;; Explicit directional hint
+    let dir-hint ""
+    if flag-x > baba-x [ set dir-hint (word dir-hint "right") ]
+    if flag-x < baba-x [ set dir-hint (word dir-hint "left") ]
+    if flag-y > baba-y [
+      if dir-hint != "" [ set dir-hint (word dir-hint " and ") ]
+      set dir-hint (word dir-hint "up")
+    ]
+    if flag-y < baba-y [
+      if dir-hint != "" [ set dir-hint (word dir-hint " and ") ]
+      set dir-hint (word dir-hint "down")
+    ]
+    if dir-hint != "" [
+      set obs (word obs "FLAG is " dir-hint " from you.\n")
+    ]
+  ]
+  set obs (word obs "\n")
+
+  ;; Active rules
+  set obs (word obs "Active Rules:\n")
+  foreach active-rules [ r ->
+    set obs (word obs "- " r "\n")
+  ]
+  if has-property? "WALL" "STOP" [
+    ;; Find the STOP block and tell the agent exactly where it is
+    let stop-block one-of word-blocks with [word-text = "STOP"]
+    ifelse stop-block != nobody [
+      let sx [xcor] of stop-block
+      let sy [ycor] of stop-block
+      set obs (word obs "!! WALLS BLOCK YOU. The [STOP] block is at (" sx ", " sy "). "
+        "Go to it and push it away to break WALL IS STOP, then walls become passable.\n")
+    ] [
+      set obs (word obs "(Walls block movement. Push the STOP word-block away to break this rule.)\n")
+    ]
+  ]
+  set obs (word obs "\n")
+
+  ;; Grid map — fixed-width for readability
+  set obs (word obs "Map (row 8=top, row 0=bottom, col 0=left, col 8=right):\n")
+  set obs (word obs "     0    1    2    3    4    5    6    7    8\n")
+  let grid-y max-pycor
+  while [grid-y >= min-pycor] [
+    let row (word grid-y "  ")
+    if grid-y < 10 [ set row (word " " row) ]
+    let grid-x min-pxcor
+    while [grid-x <= max-pxcor] [
+      let p patch grid-x grid-y
+      let cell "  .  "
+      if any? (flags-on p)       [ set cell "  F  " ]
+      if any? (rocks-on p)       [ set cell "  R  " ]
+      if any? (walls-on p)       [ set cell "  W  " ]
+      if any? (word-blocks-on p) [
+        let wb one-of (word-blocks-on p)
+        let txt [word-text] of wb
+        ;; Pad/trim to 4 chars
+        while [length txt < 4] [ set txt (word txt " ") ]
+        set cell (word "[" substring txt 0 4 "]")
+      ]
+      if any? (babas-on p)       [ set cell " YOU " ]
+      set row (word row cell)
+      set grid-x grid-x + 1
+    ]
+    set obs (word obs row "\n")
+    set grid-y grid-y - 1
+  ]
+  set obs (word obs "\n")
+
+  ;; Adjacent info
+  set obs (word obs "What is next to you:\n")
+  set obs (word obs "  up: " (describe-adjacent baba-x (baba-y + 1)) "\n")
+  set obs (word obs "  down: " (describe-adjacent baba-x (baba-y - 1)) "\n")
+  set obs (word obs "  left: " (describe-adjacent (baba-x - 1) baba-y) "\n")
+  set obs (word obs "  right: " (describe-adjacent (baba-x + 1) baba-y) "\n")
+  set obs (word obs "\n")
+
+  ;; Recent move history — helps prevent looping
+  if not empty? move-history [
+    let recent-count min (list 5 (length move-history))
+    let recent sublist move-history (length move-history - recent-count) (length move-history)
+    set obs (word obs "Your last " recent-count " moves: " reduce [ [a b] -> (word a ", " b) ] recent "\n")
+    ;; Detect looping
+    if recent-count >= 4 [
+      let unique-moves remove-duplicates recent
+      if length unique-moves <= 2 [
+        set obs (word obs "WARNING: You are stuck in a loop! Try a completely different direction.\n")
+      ]
+    ]
+    set obs (word obs "\n")
+  ]
+
+  ;; Last action feedback
+  if [last-action] of one-of babas != "" [
+    let b one-of babas
+    let result ifelse-value [last-action-succeeded?] of b [ "succeeded" ] [ "FAILED - blocked" ]
+    set obs (word obs "Last action: " [last-action] of b " (" result ")\n")
+    if not [last-action-succeeded?] of b [
+      set obs (word obs "That direction is blocked. Try a different direction.\n")
+    ]
+    set obs (word obs "\n")
+  ]
+
+  set obs (word obs "Which direction should you move?")
+  report obs
+end
+
+to-report describe-adjacent [ adj-x adj-y ]
+  let p patch adj-x adj-y
+  if p = nobody [ report "boundary (impassable)" ]
+
+  let descriptions []
+
+  if any? (babas-on p)       [ set descriptions lput "you" descriptions ]
+  if any? (word-blocks-on p) [
+    let wb one-of (word-blocks-on p)
+    set descriptions lput (word "word-block [" [word-text] of wb "] (pushable)") descriptions
+  ]
+  if any? (walls-on p) [
+    ifelse has-property? "WALL" "STOP"
+      [ set descriptions lput "wall (blocking)" descriptions ]
+      [ set descriptions lput "wall (passable)" descriptions ]
+  ]
+  if any? (rocks-on p) [
+    ifelse has-property? "ROCK" "PUSH"
+      [ set descriptions lput "rock (pushable)" descriptions ]
+      [ set descriptions lput "rock" descriptions ]
+  ]
+  if any? (flags-on p) [
+    ifelse has-property? "FLAG" "WIN"
+      [ set descriptions lput "flag (WIN!)" descriptions ]
+      [ set descriptions lput "flag" descriptions ]
+  ]
+
+  ifelse empty? descriptions
+    [ report "empty" ]
+    [ report reduce [ [a b] -> (word a ", " b) ] descriptions ]
+end
+
+;; ============================================================
+;; WIN/DEFEAT CHECK
+;; ============================================================
+
+to check-win-defeat
+  ;; Check if BABA IS YOU rule is broken
+  if not has-property? "BABA" "YOU" [
+    set game-state "lost - BABA IS YOU rule broken"
+    output-print "DEFEAT: The BABA IS YOU rule was broken!"
+    stop
+  ]
+
+  ;; Check if baba is on a flag with WIN property
+  ask babas [
+    if any? (flags-on patch-here) and has-property? "FLAG" "WIN" [
+      set game-state "won"
+      output-print (word "VICTORY! Solved in " total-moves " moves and " total-llm-calls " LLM calls.")
+    ]
+  ]
+
+  ;; Check move limit
+  if total-moves >= max-moves and game-state = "playing" [
+    set game-state "out of moves"
+    output-print (word "OUT OF MOVES after " total-moves " moves.")
+  ]
+end
+
+;; ============================================================
+;; REPORTERS FOR MONITORS
+;; ============================================================
+
+to-report level-report
+  report (word "Level " (substring level-choice 0 1))
+end
+
+to-report moves-report
+  report total-moves
+end
+
+to-report llm-calls-report
+  report total-llm-calls
+end
+
+to-report status-report
+  report game-state
+end
+
+to-report rules-report
+  ifelse empty? active-rules
+    [ report "none" ]
+    [ report reduce [ [a b] -> (word a ", " b) ] active-rules ]
+end
+  ]]></code>
+  <widgets>
+    <view x="220" wrappingAllowedX="false" y="10" frameRate="5.0" minPycor="0" height="380" showTickCounter="true" patchSize="40.0" fontSize="10" wrappingAllowedY="false" width="380" tickCounterLabel="ticks" maxPycor="8" updateMode="1" maxPxcor="8" minPxcor="0"></view>
+    <button x="15" y="10" height="40" disableUntilTicks="false" forever="false" kind="Observer" width="90" display="Setup">setup</button>
+    <button x="110" y="10" height="40" disableUntilTicks="false" forever="true" kind="Observer" width="90" display="Go">go</button>
+    <button x="15" y="55" height="40" disableUntilTicks="false" forever="false" kind="Observer" width="185" display="Step">step</button>
+    <chooser x="15" y="100" height="60" variable="level-choice" current="0" width="185" display="level-choice">
+      <choice type="string" value="1: Navigate"></choice>
+      <choice type="string" value="2: Break the Wall"></choice>
+      <choice type="string" value="3: Push and Rearrange"></choice>
+    </chooser>
+    <switch x="15" y="170" height="40" on="false" variable="show-observations?" width="185" display="show-observations?"></switch>
+    <slider x="15" step="5" y="220" max="100" width="185" display="max-moves" height="50" min="10" direction="Horizontal" default="50.0" variable="max-moves"></slider>
+    <monitor x="15" precision="17" y="280" height="60" fontSize="11" width="100" display="Level">level-report</monitor>
+    <monitor x="110" precision="17" y="280" height="60" fontSize="11" width="100" display="Moves">moves-report</monitor>
+    <monitor x="15" precision="17" y="325" height="60" fontSize="11" width="100" display="LLM Calls">llm-calls-report</monitor>
+    <monitor x="110" precision="17" y="325" height="60" fontSize="11" width="100" display="Status">status-report</monitor>
+    <monitor x="15" precision="17" y="375" height="60" fontSize="11" width="185" display="Active Rules">rules-report</monitor>
+    <plot x="620" autoPlotX="true" yMax="10.0" autoPlotY="true" yAxis="moves" y="10" xMin="0.0" height="180" legend="false" xMax="10.0" yMin="0.0" width="280" xAxis="tick" display="Moves Over Time">
+      <setup></setup>
+      <update></update>
+      <pen interval="1.0" mode="0" display="Moves" color="-2674135" legend="true">
+        <setup></setup>
+        <update>plot total-moves</update>
+      </pen>
+    </plot>
+    <plot x="620" autoPlotX="true" yMax="10.0" autoPlotY="true" yAxis="calls" y="200" xMin="0.0" height="150" legend="false" xMax="10.0" yMin="0.0" width="280" xAxis="tick" display="LLM Calls">
+      <setup></setup>
+      <update></update>
+      <pen interval="1.0" mode="0" display="Calls" color="-10899396" legend="true">
+        <setup></setup>
+        <update>plot total-llm-calls</update>
+      </pen>
+    </plot>
+    <output x="620" y="360" height="416" fontSize="10" width="1006"></output>
+  </widgets>
+  <info>## Baba Is AI
+
+### What Is It?
+
+A simplified recreation of "Baba Is You" where an LLM agent must solve puzzles by pushing word-blocks that define the rules of the world. Three consecutive word-blocks in a row or column form a rule like "BABA IS YOU" or "WALL IS STOP". The agent can push these word-blocks apart to change or break rules.
+
+### How It Works
+
+**Rules are physical objects.** Word-blocks sit on a 9x9 grid. When three blocks align as [NOUN] IS [PROPERTY], that rule takes effect. Push a block out of alignment and the rule breaks.
+
+**The LLM decides each move.** Every tick, the agent receives a text observation of the grid and chooses up/down/left/right via `llm:choose`. History accumulates so the agent can learn from failed moves.
+
+**The knowing-doing gap.** Based on the BALROG benchmark, LLMs score near 0% on Baba Is You despite understanding the rules perfectly when quizzed. They *know* rules are pushable but *cannot execute* the spatial reasoning to rearrange them.
+
+### Levels
+
+1. **Navigate** — Walk right to the flag. No rule manipulation needed.
+2. **Break the Wall** — A wall blocks the path. Push the STOP word-block away from "WALL IS STOP" to make walls passable.
+3. **Push and Rearrange** — Rocks and walls block the path. Navigate around rocks, break the wall rule, reach the flag.
+
+### How to Use
+
+1. Select a level from the chooser
+2. Click **Setup** to initialize the level
+3. Click **Go** to let the LLM agent play, or **Step** for one move at a time
+4. Toggle **show-observations?** to see what the LLM receives each turn
+5. Watch the Active Rules monitor — it updates when word-blocks are pushed
+
+### Things to Notice
+
+- Level 1 is usually solved quickly (simple navigation)
+- Level 2 requires the agent to realize it must push STOP away — most LLMs struggle here
+- Level 3 adds rocks and more complex spatial reasoning — rarely solved
+- The Active Rules monitor shows rules changing in real-time as blocks move
+
+### Extending
+
+- Edit `config` to try different LLM providers (OpenAI, Claude, Gemini)
+- Add new word types (DEFEAT, SINK) for more complex puzzles
+- Create levels where the agent must *construct* rules, not just break them
+  </info>
+  <turtleShapes>
+    <shape name="default" rotatable="true" editableColorIndex="0">
+      <polygon color="-1920102913" filled="true" marked="true">
+        <point x="150" y="5"></point>
+        <point x="40" y="250"></point>
+        <point x="150" y="205"></point>
+        <point x="260" y="250"></point>
+      </polygon>
+    </shape>
+    <shape name="circle" rotatable="false" editableColorIndex="0">
+      <circle x="0" y="0" marked="true" color="-1920102913" diameter="300" filled="true"></circle>
+    </shape>
+    <shape name="flag" rotatable="false" editableColorIndex="0">
+      <rectangle endX="75" startY="15" marked="true" color="-1920102913" endY="300" startX="60" filled="true"></rectangle>
+      <polygon color="-1920102913" filled="true" marked="true">
+        <point x="90" y="150"></point>
+        <point x="270" y="90"></point>
+        <point x="90" y="30"></point>
+      </polygon>
+      <line endX="90" startY="135" marked="true" color="-1920102913" endY="135" startX="75"></line>
+      <line endX="90" startY="45" marked="true" color="-1920102913" endY="45" startX="75"></line>
+    </shape>
+    <shape name="person" rotatable="false" editableColorIndex="0">
+      <circle x="110" y="5" marked="true" color="-1920102913" diameter="80" filled="true"></circle>
+      <polygon color="-1920102913" filled="true" marked="true">
+        <point x="105" y="90"></point>
+        <point x="120" y="195"></point>
+        <point x="90" y="285"></point>
+        <point x="105" y="300"></point>
+        <point x="135" y="300"></point>
+        <point x="150" y="225"></point>
+        <point x="165" y="300"></point>
+        <point x="195" y="300"></point>
+        <point x="210" y="285"></point>
+        <point x="180" y="195"></point>
+        <point x="195" y="90"></point>
+      </polygon>
+      <rectangle endX="172" startY="79" marked="true" color="-1920102913" endY="94" startX="127" filled="true"></rectangle>
+      <polygon color="-1920102913" filled="true" marked="true">
+        <point x="195" y="90"></point>
+        <point x="240" y="150"></point>
+        <point x="225" y="180"></point>
+        <point x="165" y="105"></point>
+      </polygon>
+      <polygon color="-1920102913" filled="true" marked="true">
+        <point x="105" y="90"></point>
+        <point x="60" y="150"></point>
+        <point x="75" y="180"></point>
+        <point x="135" y="105"></point>
+      </polygon>
+    </shape>
+    <shape name="square" rotatable="false" editableColorIndex="0">
+      <rectangle endX="270" startY="30" marked="true" color="-1920102913" endY="270" startX="30" filled="true"></rectangle>
+    </shape>
+  </turtleShapes>
+  <linkShapes>
+    <shape name="default" curviness="0.0">
+      <lines>
+        <line x="-0.2" visible="false">
+          <dash value="0.0"></dash>
+          <dash value="1.0"></dash>
+        </line>
+        <line x="0.0" visible="true">
+          <dash value="1.0"></dash>
+          <dash value="0.0"></dash>
+        </line>
+        <line x="0.2" visible="false">
+          <dash value="0.0"></dash>
+          <dash value="1.0"></dash>
+        </line>
+      </lines>
+      <indicator>
+        <shape name="link direction" rotatable="true" editableColorIndex="0">
+          <line endX="90" startY="150" marked="true" color="-1920102913" endY="180" startX="150"></line>
+          <line endX="210" startY="150" marked="true" color="-1920102913" endY="180" startX="150"></line>
+        </shape>
+      </indicator>
+    </shape>
+  </linkShapes>
+  <previewCommands>setup repeat 75 [ go ]</previewCommands>
+</model>
diff --git a/demos/baba-is-ai/config b/demos/baba-is-ai/config
new file mode 100644
index 0000000..4fcd404
--- /dev/null
+++ b/demos/baba-is-ai/config
@@ -0,0 +1,6 @@
+provider=ollama
+model=qwen2.5:7b
+base_url=http://localhost:11434
+temperature=0.3
+max_tokens=100
+timeout_seconds=45