Add Modal LLM backends and agent memory updates

README.md

@@ -74,7 +74,11 @@ applied by the server as base damage plus a deterministic random increase from 0
 to 5. Dead NPCs cannot act, but remain in the world at their death position.
 The model chooses only an action. It does not write memories directly; after all
 actions are applied, the simulation records outcome observations such as movement
-results, speech heard, attacks received, blocked movement, and death.
+results, speech heard, attacks received, and death.
+Routine movement is not stored as memory because the NPC already receives its
+current position every tick. Older meaningful memories are compacted into a
+rolling `memory_summary`, while the latest five meaningful memories remain as
+individual observations.
 
 The UI also exposes a God Console when the API runs with an OpenAI-compatible
 connector. It sends freeform commands such as "Ada wants to kill everyone",
@@ -83,6 +87,11 @@ applies the returned tool calls to the world state. Current God Console tools
 can set NPC health, attack damage, personality, divine directive, memory, and
 position.
 
+God Console can use a separate OpenAI-compatible connector via `god_console`.
+The active Modal config keeps NPC ticks on the H100 Nemotron endpoint and
+defaults God Console to a Qwen3.6-27B-FP8 H100 endpoint. Override these with
+`GOD_CONSOLE_QWEN_BASE_URL` and `GOD_CONSOLE_QWEN_MODEL`.
+
 `config/game.llm.local.json` defaults to OpenRouter's
 `nvidia/nemotron-3-ultra-550b-a55b` model. Set your OpenRouter API key before
 starting the server:
@@ -109,6 +118,92 @@ The connector choice is binary: `connector.type: "deterministic"` makes every
 tick deterministic, while `connector.type: "openai_compatible"` asks the model
 on every tick.
 
+When the UI first loads, it fetches `/claw3d/state?warmup=1`. That tells the
+backend to start fire-and-forget health warmups for configured Modal model
+endpoints. Each resolved `.modal.run/health` URL is pinged in a daemon thread
+without a request timeout. Normal UI refreshes only read the latest model
+statuses. The UI shows each model as `checking`, `warmup` if no response has
+arrived after two seconds, or `ready` after HTTP 200.
+
+For Nemotron 3 Nano tool calling, the Modal configs use reasoning-off chat
+template kwargs and NVIDIA's recommended tool-call sampling values:
+`temperature: 0.6` and `top_p: 0.95`.
+
+### Modal Nemotron Nano
+
+This repo includes a Modal deployment for
+`nvidia/NVIDIA-Nemotron-3-Nano-4B-FP8` using vLLM's OpenAI-compatible server:
+
+```powershell
+uv run python -m modal setup
+uv run python -m modal deploy deployments/modal_nemotron_nano.py
+```
+
+The deploy command prints a Modal URL such as:
+
+```text
+https://<workspace>--god-simulator-nemotron3-nano-serve.modal.run
+```
+
+Set the game connector base URL to the Modal endpoint's OpenAI-compatible `/v1`
+path, then start the API with the Modal config:
+
+```powershell
+$env:MODAL_NEMOTRON_BASE_URL="https://<workspace>--god-simulator-nemotron3-nano-serve.modal.run/v1"
+$env:MODAL_NEMOTRON_MODEL="nemotron3-nano-4b-fp8"
+uv run python -m god_simulator run --config config/game.modal.local.json
+```
+
+`config/game.modal.local.json` is the active Modal profile: NPC decisions use
+the H100 Nemotron Nano endpoint, and God Console uses the Qwen3.6 H100 endpoint.
+
+To run a Modal smoke test that checks health, chat completions, and tool calls:
+
+```powershell
+$env:MODAL_NEMOTRON_ENDPOINT="https://<workspace>--god-simulator-nemotron3-nano-serve.modal.run"
+uv run python deployments/smoke_modal_endpoint.py
+```
+
+### Modal Qwen3.6 God Console
+
+God Console uses `Qwen/Qwen3.6-27B-FP8` on a single H100. The FP8 checkpoint is
+used because the official vLLM recipe lists BF16 Qwen3.6-27B as a 2xH100 setup,
+while FP8 fits a single H100. Deploy it with:
+
+```powershell
+uv run python -X utf8 -m modal deploy deployments/modal_qwen36_27b_h100.py
+uv run python deployments/smoke_modal_endpoint.py https://<workspace>--god-simulator-qwen36-27b-h100-serve.modal.run --model qwen3.6-27b-h100-fp8
+```
+
+For cheaper development runs, deploy the T4 variant. It uses the BF16 checkpoint
+loaded as float16, lower context, one vLLM sequence, and one Modal container:
+
+```powershell
+uv run python -X utf8 -m modal deploy deployments/modal_nemotron_nano_t4.py
+uv run python deployments/smoke_modal_endpoint.py https://<workspace>--god-simulator-nemotron3-nano-t4-serve.modal.run --model nemotron3-nano-4b-t4-fp16
+uv run python -m god_simulator run --config config/game.modal.t4.local.json
+```
+
+The A10 variant is a better low-cost target for the full game tick than T4. It
+uses the BF16 checkpoint loaded as float16, one vLLM sequence, one Modal
+container, and keeps the full action response token budget:
+
+```powershell
+uv run python -X utf8 -m modal deploy deployments/modal_nemotron_nano_a10.py
+uv run python deployments/smoke_modal_endpoint.py https://<workspace>--god-simulator-nemotron3-nano-a10-serve.modal.run --model nemotron3-nano-4b-a10-fp16
+uv run python -m god_simulator run --config config/game.modal.a10.local.json
+```
+
+For a high-throughput single-container endpoint, deploy the B200 variant. It
+uses the FP8 checkpoint, one Modal container, and allows the backend to dispatch
+NPC decisions in parallel batches:
+
+```powershell
+uv run python -X utf8 -m modal deploy deployments/modal_nemotron_nano_b200.py
+uv run python deployments/smoke_modal_endpoint.py https://<workspace>--god-simulator-nemotron3-nano-b200-serve.modal.run --model nemotron3-nano-4b-b200-fp8
+uv run python -m god_simulator run --config config/game.modal.b200.local.json
+```
+
 ## Architecture
 
 The core rule is that the Python simulation owns meaning, and the 3D client owns display.

config/game.llm.local.json

@@ -6,7 +6,7 @@
     "seed": 42
   },
   "npcs": {
-    "count": 5
+    "count": 10
   },
   "simulation": {
     "tick_ms": 500
@@ -24,8 +24,27 @@
     "model": "nvidia/nemotron-3-ultra-550b-a55b",
     "api_key_env": "OPENROUTER_API_KEY",
     "timeout_seconds": 300,
+    "temperature": 0.6,
+    "top_p": 0.95,
     "max_parallel_npc_calls": 5,
     "fallback_to_deterministic": true,
     "extra_body": {}
+  },
+  "god_console": {
+    "type": "openai_compatible",
+    "base_url_env": "GOD_CONSOLE_QWEN_BASE_URL",
+    "model_env": "GOD_CONSOLE_QWEN_MODEL",
+    "base_url": "https://georgij-sawin--god-simulator-qwen36-27b-h100-serve.modal.run/v1",
+    "model": "qwen3.6-27b-h100-fp8",
+    "timeout_seconds": 600,
+    "max_tokens": 1200,
+    "temperature": 0.6,
+    "top_p": 0.95,
+    "tool_choice": "required",
+    "extra_body": {
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
   }
 }

config/game.local.json

@@ -6,7 +6,7 @@
     "seed": 42
   },
   "npcs": {
-    "count": 5
+    "count": 10
   },
   "simulation": {
     "tick_ms": 500

config/game.modal.a10.local.json

@@ -0,0 +1,54 @@
+{
+  "world": {
+    "width": 80,
+    "depth": 80,
+    "terrain": "plain_green",
+    "seed": 42
+  },
+  "npcs": {
+    "count": 10
+  },
+  "simulation": {
+    "tick_ms": 500
+  },
+  "server": {
+    "host": "127.0.0.1",
+    "port": 8000
+  },
+  "connector": {
+    "type": "openai_compatible",
+    "base_url_env": "MODAL_NEMOTRON_A10_BASE_URL",
+    "model_env": "MODAL_NEMOTRON_A10_MODEL",
+    "base_url": "https://georgij-sawin--god-simulator-nemotron3-nano-a10-serve.modal.run/v1",
+    "model": "nemotron3-nano-4b-a10-fp16",
+    "timeout_seconds": 600,
+    "max_tokens": 1400,
+    "temperature": 0.6,
+    "top_p": 0.95,
+    "tool_choice": "required",
+    "max_parallel_npc_calls": 1,
+    "fallback_to_deterministic": true,
+    "extra_body": {
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  },
+  "god_console": {
+    "type": "openai_compatible",
+    "base_url_env": "GOD_CONSOLE_QWEN_BASE_URL",
+    "model_env": "GOD_CONSOLE_QWEN_MODEL",
+    "base_url": "https://georgij-sawin--god-simulator-qwen36-27b-h100-serve.modal.run/v1",
+    "model": "qwen3.6-27b-h100-fp8",
+    "timeout_seconds": 600,
+    "max_tokens": 1200,
+    "temperature": 0.6,
+    "top_p": 0.95,
+    "tool_choice": "required",
+    "extra_body": {
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  }
+}

config/game.modal.b200.local.json

@@ -0,0 +1,54 @@
+{
+  "world": {
+    "width": 80,
+    "depth": 80,
+    "terrain": "plain_green",
+    "seed": 42
+  },
+  "npcs": {
+    "count": 10
+  },
+  "simulation": {
+    "tick_ms": 500
+  },
+  "server": {
+    "host": "127.0.0.1",
+    "port": 8000
+  },
+  "connector": {
+    "type": "openai_compatible",
+    "base_url_env": "MODAL_NEMOTRON_B200_BASE_URL",
+    "model_env": "MODAL_NEMOTRON_B200_MODEL",
+    "base_url": "https://georgij-sawin--god-simulator-nemotron3-nano-b200-serve.modal.run/v1",
+    "model": "nemotron3-nano-4b-b200-fp8",
+    "timeout_seconds": 600,
+    "max_tokens": 1400,
+    "temperature": 0.6,
+    "top_p": 0.95,
+    "tool_choice": "required",
+    "max_parallel_npc_calls": 5,
+    "fallback_to_deterministic": true,
+    "extra_body": {
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  },
+  "god_console": {
+    "type": "openai_compatible",
+    "base_url_env": "GOD_CONSOLE_QWEN_BASE_URL",
+    "model_env": "GOD_CONSOLE_QWEN_MODEL",
+    "base_url": "https://georgij-sawin--god-simulator-qwen36-27b-h100-serve.modal.run/v1",
+    "model": "qwen3.6-27b-h100-fp8",
+    "timeout_seconds": 600,
+    "max_tokens": 1200,
+    "temperature": 0.6,
+    "top_p": 0.95,
+    "tool_choice": "required",
+    "extra_body": {
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  }
+}

config/game.modal.local.json

@@ -0,0 +1,54 @@
+{
+  "world": {
+    "width": 80,
+    "depth": 80,
+    "terrain": "plain_green",
+    "seed": 42
+  },
+  "npcs": {
+    "count": 10
+  },
+  "simulation": {
+    "tick_ms": 500
+  },
+  "server": {
+    "host": "127.0.0.1",
+    "port": 8000
+  },
+  "connector": {
+    "type": "openai_compatible",
+    "base_url_env": "MODAL_NEMOTRON_BASE_URL",
+    "model_env": "MODAL_NEMOTRON_MODEL",
+    "base_url": "https://georgij-sawin--god-simulator-nemotron3-nano-serve.modal.run/v1",
+    "model": "nemotron3-nano-4b-fp8",
+    "timeout_seconds": 600,
+    "max_tokens": 1400,
+    "temperature": 0.6,
+    "top_p": 0.95,
+    "tool_choice": "required",
+    "max_parallel_npc_calls": 8,
+    "fallback_to_deterministic": true,
+    "extra_body": {
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  },
+  "god_console": {
+    "type": "openai_compatible",
+    "base_url_env": "GOD_CONSOLE_QWEN_BASE_URL",
+    "model_env": "GOD_CONSOLE_QWEN_MODEL",
+    "base_url": "https://georgij-sawin--god-simulator-qwen36-27b-h100-serve.modal.run/v1",
+    "model": "qwen3.6-27b-h100-fp8",
+    "timeout_seconds": 600,
+    "max_tokens": 1200,
+    "temperature": 0.6,
+    "top_p": 0.95,
+    "tool_choice": "required",
+    "extra_body": {
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  }
+}

config/game.modal.t4.local.json

@@ -0,0 +1,54 @@
+{
+  "world": {
+    "width": 80,
+    "depth": 80,
+    "terrain": "plain_green",
+    "seed": 42
+  },
+  "npcs": {
+    "count": 10
+  },
+  "simulation": {
+    "tick_ms": 500
+  },
+  "server": {
+    "host": "127.0.0.1",
+    "port": 8000
+  },
+  "connector": {
+    "type": "openai_compatible",
+    "base_url_env": "MODAL_NEMOTRON_T4_BASE_URL",
+    "model_env": "MODAL_NEMOTRON_T4_MODEL",
+    "base_url": "https://georgij-sawin--god-simulator-nemotron3-nano-t4-serve.modal.run/v1",
+    "model": "nemotron3-nano-4b-t4-fp16",
+    "timeout_seconds": 300,
+    "max_tokens": 256,
+    "temperature": 0.6,
+    "top_p": 0.95,
+    "tool_choice": "required",
+    "max_parallel_npc_calls": 1,
+    "fallback_to_deterministic": true,
+    "extra_body": {
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  },
+  "god_console": {
+    "type": "openai_compatible",
+    "base_url_env": "GOD_CONSOLE_QWEN_BASE_URL",
+    "model_env": "GOD_CONSOLE_QWEN_MODEL",
+    "base_url": "https://georgij-sawin--god-simulator-qwen36-27b-h100-serve.modal.run/v1",
+    "model": "qwen3.6-27b-h100-fp8",
+    "timeout_seconds": 600,
+    "max_tokens": 1200,
+    "temperature": 0.6,
+    "top_p": 0.95,
+    "tool_choice": "required",
+    "extra_body": {
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  }
+}

deployments/modal_nemotron_nano.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import os
+import subprocess
+
+import modal
+
+MINUTES = 60
+
+APP_NAME = "god-simulator-nemotron3-nano"
+MODEL_NAME = "nvidia/NVIDIA-Nemotron-3-Nano-4B-FP8"
+SERVED_MODEL_NAME = "nemotron3-nano-4b-fp8"
+REASONING_PARSER_URL = (
+    "https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16/"
+    "resolve/main/nano_v3_reasoning_parser.py"
+)
+REASONING_PARSER_PATH = "/root/nano_v3_reasoning_parser.py"
+
+VLLM_PORT = 8000
+GPU_TYPE = os.environ.get("MODAL_NEMOTRON_GPU", "H100")
+MAX_MODEL_LEN = int(os.environ.get("MODAL_NEMOTRON_MAX_MODEL_LEN", "32768"))
+MAX_NUM_SEQS = int(os.environ.get("MODAL_NEMOTRON_MAX_NUM_SEQS", "8"))
+TARGET_INPUTS = int(os.environ.get("MODAL_NEMOTRON_TARGET_INPUTS", "8"))
+
+hf_cache_vol = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
+vllm_cache_vol = modal.Volume.from_name("vllm-cache", create_if_missing=True)
+
+vllm_image = (
+    modal.Image.from_registry(
+        "vllm/vllm-openai:v0.15.1",
+        setup_dockerfile_commands=["RUN ln -sf $(which python3) /usr/bin/python"],
+    )
+    .entrypoint([])
+    .run_commands(
+        "python3 -m pip install --upgrade "
+        "'typing_extensions>=4.15.0' 'aiohttp>=3.13.3' 'protobuf>=6.33.5,<7'",
+        "python3 -c \"import urllib.request; "
+        f"urllib.request.urlretrieve('{REASONING_PARSER_URL}', '{REASONING_PARSER_PATH}')\""
+    )
+    .env(
+        {
+            "HF_HUB_CACHE": "/root/.cache/huggingface",
+            "HF_XET_HIGH_PERFORMANCE": "1",
+            "VLLM_LOG_STATS_INTERVAL": "10",
+            "TORCH_CPP_LOG_LEVEL": "FATAL",
+        }
+    )
+)
+
+app = modal.App(APP_NAME)
+
+
+@app.function(
+    image=vllm_image,
+    gpu=GPU_TYPE,
+    volumes={
+        "/root/.cache/huggingface": hf_cache_vol,
+        "/root/.cache/vllm": vllm_cache_vol,
+    },
+    scaledown_window=2 * MINUTES,
+    timeout=30 * MINUTES,
+)
+@modal.concurrent(max_inputs=TARGET_INPUTS)
+@modal.web_server(port=VLLM_PORT, startup_timeout=30 * MINUTES)
+def serve() -> None:
+    cmd = [
+        "vllm",
+        "serve",
+        MODEL_NAME,
+        "--served-model-name",
+        SERVED_MODEL_NAME,
+        "--host",
+        "0.0.0.0",
+        "--port",
+        str(VLLM_PORT),
+        "--max-num-seqs",
+        str(MAX_NUM_SEQS),
+        "--tensor-parallel-size",
+        "1",
+        "--max-model-len",
+        str(MAX_MODEL_LEN),
+        "--trust-remote-code",
+        "--mamba_ssm_cache_dtype",
+        "float32",
+        "--enable-auto-tool-choice",
+        "--tool-call-parser",
+        "qwen3_coder",
+        "--reasoning-parser-plugin",
+        REASONING_PARSER_PATH,
+        "--reasoning-parser",
+        "nano_v3",
+        "--kv-cache-dtype",
+        "fp8",
+        "--gpu-memory-utilization",
+        "0.9",
+    ]
+    print(*cmd, flush=True)
+    subprocess.Popen(cmd)

deployments/modal_nemotron_nano_a10.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import os
+import subprocess
+
+import modal
+
+MINUTES = 60
+
+APP_NAME = "god-simulator-nemotron3-nano-a10"
+MODEL_NAME = "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
+SERVED_MODEL_NAME = "nemotron3-nano-4b-a10-fp16"
+REASONING_PARSER_URL = (
+    "https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16/"
+    "resolve/main/nano_v3_reasoning_parser.py"
+)
+REASONING_PARSER_PATH = "/root/nano_v3_reasoning_parser.py"
+
+VLLM_PORT = 8000
+GPU_TYPE = os.environ.get("MODAL_NEMOTRON_A10_GPU", "A10G")
+MAX_MODEL_LEN = int(os.environ.get("MODAL_NEMOTRON_A10_MAX_MODEL_LEN", "4096"))
+MAX_NUM_SEQS = int(os.environ.get("MODAL_NEMOTRON_A10_MAX_NUM_SEQS", "1"))
+TARGET_INPUTS = int(os.environ.get("MODAL_NEMOTRON_A10_TARGET_INPUTS", "1"))
+
+hf_cache_vol = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
+vllm_cache_vol = modal.Volume.from_name("vllm-cache", create_if_missing=True)
+
+vllm_image = (
+    modal.Image.from_registry(
+        "vllm/vllm-openai:v0.15.1",
+        setup_dockerfile_commands=["RUN ln -sf $(which python3) /usr/bin/python"],
+    )
+    .entrypoint([])
+    .run_commands(
+        "python3 -m pip install --upgrade "
+        "'typing_extensions>=4.15.0' 'aiohttp>=3.13.3' 'protobuf>=6.33.5,<7'",
+        "python3 -c \"import urllib.request; "
+        f"urllib.request.urlretrieve('{REASONING_PARSER_URL}', '{REASONING_PARSER_PATH}')\""
+    )
+    .env(
+        {
+            "HF_HUB_CACHE": "/root/.cache/huggingface",
+            "HF_XET_HIGH_PERFORMANCE": "1",
+            "VLLM_LOG_STATS_INTERVAL": "10",
+            "TORCH_CPP_LOG_LEVEL": "FATAL",
+        }
+    )
+)
+
+app = modal.App(APP_NAME)
+
+
+@app.function(
+    image=vllm_image,
+    gpu=GPU_TYPE,
+    volumes={
+        "/root/.cache/huggingface": hf_cache_vol,
+        "/root/.cache/vllm": vllm_cache_vol,
+    },
+    max_containers=1,
+    scaledown_window=2 * MINUTES,
+    timeout=30 * MINUTES,
+)
+@modal.concurrent(max_inputs=TARGET_INPUTS, target_inputs=TARGET_INPUTS)
+@modal.web_server(port=VLLM_PORT, startup_timeout=30 * MINUTES)
+def serve() -> None:
+    cmd = [
+        "vllm",
+        "serve",
+        MODEL_NAME,
+        "--served-model-name",
+        SERVED_MODEL_NAME,
+        "--host",
+        "0.0.0.0",
+        "--port",
+        str(VLLM_PORT),
+        "--max-num-seqs",
+        str(MAX_NUM_SEQS),
+        "--tensor-parallel-size",
+        "1",
+        "--max-model-len",
+        str(MAX_MODEL_LEN),
+        "--dtype",
+        "float16",
+        "--trust-remote-code",
+        "--mamba_ssm_cache_dtype",
+        "float32",
+        "--enable-auto-tool-choice",
+        "--tool-call-parser",
+        "qwen3_coder",
+        "--reasoning-parser-plugin",
+        REASONING_PARSER_PATH,
+        "--reasoning-parser",
+        "nano_v3",
+        "--gpu-memory-utilization",
+        "0.85",
+        "--enforce-eager",
+    ]
+    print(*cmd, flush=True)
+    subprocess.Popen(cmd)

deployments/modal_nemotron_nano_b200.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import os
+import subprocess
+
+import modal
+
+MINUTES = 60
+
+APP_NAME = "god-simulator-nemotron3-nano-b200"
+MODEL_NAME = "nvidia/NVIDIA-Nemotron-3-Nano-4B-FP8"
+SERVED_MODEL_NAME = "nemotron3-nano-4b-b200-fp8"
+REASONING_PARSER_URL = (
+    "https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16/"
+    "resolve/main/nano_v3_reasoning_parser.py"
+)
+REASONING_PARSER_PATH = "/root/nano_v3_reasoning_parser.py"
+
+VLLM_PORT = 8000
+GPU_TYPE = os.environ.get("MODAL_NEMOTRON_B200_GPU", "B200")
+MAX_MODEL_LEN = int(os.environ.get("MODAL_NEMOTRON_B200_MAX_MODEL_LEN", "32768"))
+MAX_NUM_SEQS = int(os.environ.get("MODAL_NEMOTRON_B200_MAX_NUM_SEQS", "8"))
+TARGET_INPUTS = int(os.environ.get("MODAL_NEMOTRON_B200_TARGET_INPUTS", "5"))
+
+hf_cache_vol = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
+vllm_cache_vol = modal.Volume.from_name("vllm-cache", create_if_missing=True)
+
+vllm_image = (
+    modal.Image.from_registry(
+        "vllm/vllm-openai:v0.15.1",
+        setup_dockerfile_commands=["RUN ln -sf $(which python3) /usr/bin/python"],
+    )
+    .entrypoint([])
+    .run_commands(
+        "python3 -m pip install --upgrade "
+        "'typing_extensions>=4.15.0' 'aiohttp>=3.13.3' 'protobuf>=6.33.5,<7'",
+        "python3 -c \"import urllib.request; "
+        f"urllib.request.urlretrieve('{REASONING_PARSER_URL}', '{REASONING_PARSER_PATH}')\""
+    )
+    .env(
+        {
+            "HF_HUB_CACHE": "/root/.cache/huggingface",
+            "HF_XET_HIGH_PERFORMANCE": "1",
+            "VLLM_LOG_STATS_INTERVAL": "10",
+            "TORCH_CPP_LOG_LEVEL": "FATAL",
+        }
+    )
+)
+
+app = modal.App(APP_NAME)
+
+
+@app.function(
+    image=vllm_image,
+    gpu=GPU_TYPE,
+    volumes={
+        "/root/.cache/huggingface": hf_cache_vol,
+        "/root/.cache/vllm": vllm_cache_vol,
+    },
+    max_containers=1,
+    scaledown_window=2 * MINUTES,
+    timeout=30 * MINUTES,
+)
+@modal.concurrent(max_inputs=TARGET_INPUTS, target_inputs=TARGET_INPUTS)
+@modal.web_server(port=VLLM_PORT, startup_timeout=30 * MINUTES)
+def serve() -> None:
+    cmd = [
+        "vllm",
+        "serve",
+        MODEL_NAME,
+        "--served-model-name",
+        SERVED_MODEL_NAME,
+        "--host",
+        "0.0.0.0",
+        "--port",
+        str(VLLM_PORT),
+        "--max-num-seqs",
+        str(MAX_NUM_SEQS),
+        "--tensor-parallel-size",
+        "1",
+        "--max-model-len",
+        str(MAX_MODEL_LEN),
+        "--trust-remote-code",
+        "--mamba_ssm_cache_dtype",
+        "float32",
+        "--enable-auto-tool-choice",
+        "--tool-call-parser",
+        "qwen3_coder",
+        "--reasoning-parser-plugin",
+        REASONING_PARSER_PATH,
+        "--reasoning-parser",
+        "nano_v3",
+        "--kv-cache-dtype",
+        "fp8",
+        "--gpu-memory-utilization",
+        "0.9",
+    ]
+    print(*cmd, flush=True)
+    subprocess.Popen(cmd)

deployments/modal_nemotron_nano_t4.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import os
+import subprocess
+
+import modal
+
+MINUTES = 60
+
+APP_NAME = "god-simulator-nemotron3-nano-t4"
+MODEL_NAME = "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
+SERVED_MODEL_NAME = "nemotron3-nano-4b-t4-fp16"
+REASONING_PARSER_URL = (
+    "https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16/"
+    "resolve/main/nano_v3_reasoning_parser.py"
+)
+REASONING_PARSER_PATH = "/root/nano_v3_reasoning_parser.py"
+
+VLLM_PORT = 8000
+GPU_TYPE = os.environ.get("MODAL_NEMOTRON_T4_GPU", "T4")
+MAX_MODEL_LEN = int(os.environ.get("MODAL_NEMOTRON_T4_MAX_MODEL_LEN", "2048"))
+MAX_NUM_SEQS = int(os.environ.get("MODAL_NEMOTRON_T4_MAX_NUM_SEQS", "1"))
+TARGET_INPUTS = int(os.environ.get("MODAL_NEMOTRON_T4_TARGET_INPUTS", "1"))
+
+hf_cache_vol = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
+vllm_cache_vol = modal.Volume.from_name("vllm-cache", create_if_missing=True)
+
+vllm_image = (
+    modal.Image.from_registry(
+        "vllm/vllm-openai:v0.15.1",
+        setup_dockerfile_commands=["RUN ln -sf $(which python3) /usr/bin/python"],
+    )
+    .entrypoint([])
+    .run_commands(
+        "python3 -m pip install --upgrade "
+        "'typing_extensions>=4.15.0' 'aiohttp>=3.13.3' 'protobuf>=6.33.5,<7'",
+        "python3 -c \"import urllib.request; "
+        f"urllib.request.urlretrieve('{REASONING_PARSER_URL}', '{REASONING_PARSER_PATH}')\""
+    )
+    .env(
+        {
+            "HF_HUB_CACHE": "/root/.cache/huggingface",
+            "HF_XET_HIGH_PERFORMANCE": "1",
+            "VLLM_LOG_STATS_INTERVAL": "10",
+            "TORCH_CPP_LOG_LEVEL": "FATAL",
+        }
+    )
+)
+
+app = modal.App(APP_NAME)
+
+
+@app.function(
+    image=vllm_image,
+    gpu=GPU_TYPE,
+    volumes={
+        "/root/.cache/huggingface": hf_cache_vol,
+        "/root/.cache/vllm": vllm_cache_vol,
+    },
+    max_containers=1,
+    scaledown_window=1 * MINUTES,
+    timeout=30 * MINUTES,
+)
+@modal.concurrent(max_inputs=TARGET_INPUTS, target_inputs=TARGET_INPUTS)
+@modal.web_server(port=VLLM_PORT, startup_timeout=30 * MINUTES)
+def serve() -> None:
+    cmd = [
+        "vllm",
+        "serve",
+        MODEL_NAME,
+        "--served-model-name",
+        SERVED_MODEL_NAME,
+        "--host",
+        "0.0.0.0",
+        "--port",
+        str(VLLM_PORT),
+        "--max-num-seqs",
+        str(MAX_NUM_SEQS),
+        "--tensor-parallel-size",
+        "1",
+        "--max-model-len",
+        str(MAX_MODEL_LEN),
+        "--dtype",
+        "float16",
+        "--trust-remote-code",
+        "--mamba_ssm_cache_dtype",
+        "float32",
+        "--enable-auto-tool-choice",
+        "--tool-call-parser",
+        "qwen3_coder",
+        "--reasoning-parser-plugin",
+        REASONING_PARSER_PATH,
+        "--reasoning-parser",
+        "nano_v3",
+        "--gpu-memory-utilization",
+        "0.6",
+        "--enforce-eager",
+    ]
+    print(*cmd, flush=True)
+    subprocess.Popen(cmd)

deployments/modal_qwen36_27b_h100.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import os
+import subprocess
+
+import modal
+
+MINUTES = 60
+
+APP_NAME = "god-simulator-qwen36-27b-h100"
+MODEL_NAME = "Qwen/Qwen3.6-27B-FP8"
+SERVED_MODEL_NAME = "qwen3.6-27b-h100-fp8"
+
+VLLM_PORT = 8000
+GPU_TYPE = os.environ.get("MODAL_QWEN36_GPU", "H100")
+MAX_MODEL_LEN = int(os.environ.get("MODAL_QWEN36_MAX_MODEL_LEN", "32768"))
+MAX_NUM_SEQS = int(os.environ.get("MODAL_QWEN36_MAX_NUM_SEQS", "2"))
+TARGET_INPUTS = int(os.environ.get("MODAL_QWEN36_TARGET_INPUTS", "2"))
+
+hf_cache_vol = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
+vllm_cache_vol = modal.Volume.from_name("vllm-cache", create_if_missing=True)
+
+vllm_image = (
+    modal.Image.from_registry(
+        "vllm/vllm-openai:v0.19.0",
+        setup_dockerfile_commands=["RUN ln -sf $(which python3) /usr/bin/python"],
+    )
+    .entrypoint([])
+    .run_commands(
+        "python3 -m pip install --upgrade "
+        "'typing_extensions>=4.15.0' 'aiohttp>=3.13.3' 'protobuf>=6.33.5,<7'"
+    )
+    .env(
+        {
+            "HF_HUB_CACHE": "/root/.cache/huggingface",
+            "HF_XET_HIGH_PERFORMANCE": "1",
+            "VLLM_LOG_STATS_INTERVAL": "10",
+            "TORCH_CPP_LOG_LEVEL": "FATAL",
+        }
+    )
+)
+
+app = modal.App(APP_NAME)
+
+
+@app.function(
+    image=vllm_image,
+    gpu=GPU_TYPE,
+    volumes={
+        "/root/.cache/huggingface": hf_cache_vol,
+        "/root/.cache/vllm": vllm_cache_vol,
+    },
+    max_containers=1,
+    scaledown_window=2 * MINUTES,
+    timeout=30 * MINUTES,
+)
+@modal.concurrent(max_inputs=TARGET_INPUTS, target_inputs=TARGET_INPUTS)
+@modal.web_server(port=VLLM_PORT, startup_timeout=30 * MINUTES)
+def serve() -> None:
+    cmd = [
+        "vllm",
+        "serve",
+        MODEL_NAME,
+        "--served-model-name",
+        SERVED_MODEL_NAME,
+        "--host",
+        "0.0.0.0",
+        "--port",
+        str(VLLM_PORT),
+        "--max-num-seqs",
+        str(MAX_NUM_SEQS),
+        "--tensor-parallel-size",
+        "1",
+        "--max-model-len",
+        str(MAX_MODEL_LEN),
+        "--trust-remote-code",
+        "--enable-auto-tool-choice",
+        "--tool-call-parser",
+        "qwen3_coder",
+        "--reasoning-parser",
+        "qwen3",
+        "--language-model-only",
+        "--kv-cache-dtype",
+        "fp8",
+        "--gpu-memory-utilization",
+        "0.9",
+        "--default-chat-template-kwargs",
+        '{"enable_thinking": false}',
+    ]
+    print(*cmd, flush=True)
+    subprocess.Popen(cmd)

deployments/smoke_modal_endpoint.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import time
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+DEFAULT_MODEL = "nemotron3-nano-4b-fp8"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Smoke-test the deployed Modal vLLM OpenAI-compatible endpoint."
+    )
+    parser.add_argument(
+        "endpoint",
+        nargs="?",
+        default=os.getenv("MODAL_NEMOTRON_ENDPOINT"),
+        help="Modal endpoint root URL, for example https://...modal.run.",
+    )
+    parser.add_argument("--model", default=os.getenv("MODAL_NEMOTRON_MODEL", DEFAULT_MODEL))
+    parser.add_argument("--timeout-seconds", type=int, default=1800)
+    args = parser.parse_args()
+
+    if not args.endpoint:
+        raise SystemExit(
+            "Pass the Modal endpoint URL or set MODAL_NEMOTRON_ENDPOINT. "
+            "Use the root URL, not the /v1 path."
+        )
+
+    endpoint = _normalize_root_url(args.endpoint)
+    wait_for_health(endpoint, timeout_seconds=args.timeout_seconds)
+    chat(endpoint, model=args.model)
+    tool_check(endpoint, model=args.model)
+
+
+def wait_for_health(endpoint: str, *, timeout_seconds: int) -> None:
+    deadline = time.monotonic() + timeout_seconds
+    health_url = f"{endpoint}/health"
+    while time.monotonic() < deadline:
+        try:
+            with urlopen(health_url, timeout=30) as response:
+                if response.status == 200:
+                    print("Health check passed.")
+                    return
+        except (HTTPError, URLError, TimeoutError):
+            pass
+        time.sleep(5)
+    raise TimeoutError(f"Endpoint did not become healthy before timeout: {health_url}")
+
+
+def chat(endpoint: str, *, model: str) -> None:
+    body = _post_json(
+        f"{endpoint}/v1/chat/completions",
+        {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": "You answer directly and briefly."},
+                {"role": "user", "content": "What is the capital of Bulgaria?"},
+            ],
+            "max_tokens": 64,
+            "temperature": 0.6,
+            "top_p": 0.95,
+            "chat_template_kwargs": {"enable_thinking": False},
+        },
+        timeout=180,
+    )
+    message = body["choices"][0]["message"]
+    print("Chat response:")
+    print(message.get("content") or json.dumps(message, indent=2))
+
+
+def tool_check(endpoint: str, *, model: str) -> None:
+    body = _post_json(
+        f"{endpoint}/v1/chat/completions",
+        {
+            "model": model,
+            "messages": [
+                {
+                    "role": "system",
+                    "content": "You are an NPC controller. Use the walk tool exactly once.",
+                },
+                {"role": "user", "content": "Move npc-001 to x=4 and z=0."},
+            ],
+            "tools": [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "walk",
+                        "description": "Move one NPC to a target coordinate.",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "npc_id": {"type": "string"},
+                                "target_x": {"type": "number"},
+                                "target_z": {"type": "number"},
+                            },
+                            "required": ["npc_id", "target_x", "target_z"],
+                            "additionalProperties": False,
+                        },
+                    },
+                }
+            ],
+            "tool_choice": "auto",
+            "max_tokens": 128,
+            "temperature": 0.6,
+            "top_p": 0.95,
+            "chat_template_kwargs": {"enable_thinking": False},
+        },
+        timeout=180,
+    )
+    message = body["choices"][0]["message"]
+    tool_calls = message.get("tool_calls") or []
+    if not tool_calls:
+        print(json.dumps(message, indent=2))
+        raise RuntimeError("Tool check failed: response did not include tool_calls.")
+
+    print("Tool check passed:")
+    print(json.dumps(tool_calls, indent=2))
+
+
+def _post_json(url: str, payload: dict[str, Any], *, timeout: int) -> dict[str, Any]:
+    data = json.dumps(payload).encode("utf-8")
+    request = Request(
+        url,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    with urlopen(request, timeout=timeout) as response:
+        decoded = json.loads(response.read().decode("utf-8"))
+    if not isinstance(decoded, dict):
+        raise RuntimeError("Expected JSON object response.")
+    return decoded
+
+
+def _normalize_root_url(raw: str) -> str:
+    root = raw.strip().rstrip("/")
+    if root.endswith("/v1"):
+        root = root.removesuffix("/v1")
+    if not root.startswith(("http://", "https://")):
+        raise ValueError("Endpoint must start with http:// or https://.")
+    return root
+
+
+if __name__ == "__main__":
+    main()

frontend/src/App.tsx

@@ -81,7 +81,7 @@ export function App() {
 
   useEffect(() => {
     const abortController = new AbortController();
-    fetchWorldSnapshot(abortController.signal)
+    fetchWorldSnapshot(abortController.signal, { warmup: true })
       .then((nextSnapshot) => {
         setSnapshot(nextSnapshot);
         setSelectedId(nextSnapshot.entities[0]?.id ?? null);
@@ -123,6 +123,22 @@ export function App() {
     return () => window.clearInterval(intervalId);
   }, [isServerTickPending, refresh]);
 
+  const modelStatuses = snapshot?.simulation.models ?? [];
+
+  useEffect(() => {
+    if (!snapshot || !modelStatuses.some((model) => model.status !== "ready")) {
+      return;
+    }
+
+    const intervalId = window.setInterval(() => {
+      refresh().catch((nextError) => {
+        setError(nextError instanceof Error ? nextError.message : "World refresh failed");
+      });
+    }, 2000);
+
+    return () => window.clearInterval(intervalId);
+  }, [modelStatuses, refresh, snapshot]);
+
   const selectedEntity = useMemo(
     () => snapshot?.entities.find((entity) => entity.id === selectedId) ?? null,
     [selectedId, snapshot],
@@ -169,6 +185,15 @@ export function App() {
           <TooltipLabel className="statusPill" value={tickLabel} />
           <TooltipLabel className="statusPill" value={npcCountLabel} />
           <TooltipLabel className="statusPill" value={simulatorLabel} />
+          {modelStatuses.map((model) => (
+            <TooltipLabel
+              key={model.id}
+              className={`statusPill modelStatus ${modelStatusClass(model.status)}`}
+              value={`${model.label}: ${model.model ?? "unknown model"} - ${formatModelStatus(model.status)}`}
+            >
+              {`${shortModelLabel(model.label)} ${formatModelStatus(model.status)}`}
+            </TooltipLabel>
+          ))}
         </div>
       </div>
 
@@ -250,6 +275,12 @@ export function App() {
               </div>
             ) : null}
             <div className="memoryList" aria-label={`${selectedEntity.label} memories`}>
+              {selectedEntity.state.memory_summary ? (
+                <div className="memorySummary">
+                  <TooltipLabel className="memoryTick" value="Summary" />
+                  <p>{selectedEntity.state.memory_summary}</p>
+                </div>
+              ) : null}
               {selectedEntity.state.memories
                 .slice()
                 .reverse()
@@ -336,3 +367,36 @@ function TooltipLabel({ value, className, children }: TooltipLabelProps) {
     </span>
   );
 }
+
+function shortModelLabel(label: string): string {
+  return label === "God Console" ? "God" : "NPC";
+}
+
+function formatModelStatus(status: string): string {
+  switch (status) {
+    case "checking":
+      return "checking";
+    case "warmup":
+      return "warmup";
+    case "ready":
+      return "ready";
+    case "error":
+      return "error";
+    default:
+      return "unknown";
+  }
+}
+
+function modelStatusClass(status: string): string {
+  switch (status) {
+    case "ready":
+      return "modelStatusReady";
+    case "checking":
+    case "warmup":
+      return "modelStatusWarmup";
+    case "error":
+      return "modelStatusError";
+    default:
+      return "modelStatusUnknown";
+  }
+}

frontend/src/api.ts

@@ -12,8 +12,16 @@ export class ApiResponseError extends Error {
   }
 }
 
-export async function fetchWorldSnapshot(signal?: AbortSignal): Promise<WorldSnapshot> {
-  const response = await fetch(`${API_BASE}/claw3d/state`, { signal });
+export async function fetchWorldSnapshot(
+  signal?: AbortSignal,
+  options: { warmup?: boolean } = {},
+): Promise<WorldSnapshot> {
+  const url = new URL(`${API_BASE}/claw3d/state`, window.location.origin);
+  if (options.warmup) {
+    url.searchParams.set("warmup", "1");
+  }
+
+  const response = await fetch(url, { signal });
   if (!response.ok) {
     throw new ApiResponseError(`World snapshot failed: ${response.status}`, response.status);
   }

frontend/src/styles.css

@@ -44,7 +44,7 @@ button {
   top: 14px;
   left: 14px;
   right: 14px;
-  z-index: 30;
+  z-index: 60;
   display: flex;
   align-items: center;
   justify-content: space-between;
@@ -103,6 +103,23 @@ button {
   text-align: center;
 }
 
+.modelStatus {
+  min-width: 86px;
+}
+
+.modelStatusReady {
+  color: #d9f4cf;
+}
+
+.modelStatusWarmup,
+.modelStatusUnknown {
+  color: #fff3a1;
+}
+
+.modelStatusError {
+  color: #ffd3c8;
+}
+
 .controls {
   position: absolute;
   right: 14px;
@@ -293,6 +310,7 @@ button {
   padding: 9px 10px 10px;
 }
 
+.memorySummary,
 .memoryItem {
   display: grid;
   gap: 4px;
@@ -300,6 +318,10 @@ button {
   border-bottom: 1px solid rgb(255 255 255 / 10%);
 }
 
+.memorySummary {
+  padding-top: 0;
+}
+
 .memoryItem:last-child {
   border-bottom: 0;
 }
@@ -310,6 +332,7 @@ button {
   line-height: 1.1;
 }
 
+.memorySummary p,
 .memoryItem p {
   position: relative;
   margin: 0;
@@ -318,6 +341,10 @@ button {
   line-height: 1.35;
 }
 
+.memorySummary p {
+  color: rgb(245 247 240 / 72%);
+}
+
 .tooltipAnchor {
   position: relative;
   min-width: 0;

frontend/src/types.ts

@@ -32,6 +32,7 @@ export type EntitySnapshot = {
     god_directive: string | null;
     is_alive: boolean;
     memory_count: number;
+    memory_summary: string | null;
     memories: MemorySnapshot[];
   };
   render: {
@@ -54,7 +55,16 @@ export type WorldSnapshot = {
     last_tick_source: string;
     tick_in_progress: boolean;
     pending_tick: number | null;
+    models?: ModelStatusSnapshot[];
   };
   terrain: TerrainSnapshot;
   entities: EntitySnapshot[];
 };
+
+export type ModelStatusSnapshot = {
+  id: string;
+  label: string;
+  model: string | null;
+  status: "unknown" | "checking" | "warmup" | "ready" | "error" | string;
+  http_status: number | null;
+};

pyproject.toml

@@ -18,6 +18,10 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [dependency-groups]
+deploy = [
+    "aiohttp>=3.14.1",
+    "modal>=1.4.3",
+]
 dev = [
     "pytest>=8.0",
     "ruff>=0.8",

src/god_simulator/api/server.py

@@ -1,14 +1,18 @@
 from __future__ import annotations
 
 import json
+import time
 from copy import deepcopy
 from dataclasses import dataclass
 from http import HTTPStatus
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from threading import Lock
-from typing import Any
+from threading import Lock, Thread
+from typing import Any, Protocol
+from urllib.error import HTTPError, URLError
+from urllib.parse import parse_qs, urlparse
+from urllib.request import urlopen
 
-from god_simulator.config import GameConfig
+from god_simulator.config import ConnectorConfig, GameConfig
 from god_simulator.domain import WorldState
 from god_simulator.rendering.claw3d_contract import to_claw3d_snapshot
 from god_simulator.simulation.connectors.base import WorldSimulator
@@ -22,10 +26,14 @@ from god_simulator.simulation.tick import apply_tick_plan, plan_world_tick
 
 def run_server(*, world: WorldState, config: GameConfig) -> None:
     simulator = create_world_simulator(config)
+    god_console_config = config.god_console or config.connector
     god_console = (
-        GodConsole(config.connector) if config.connector.type == "openai_compatible" else None
+        GodConsole(god_console_config)
+        if god_console_config.type == "openai_compatible"
+        else None
     )
-    handler = _build_handler(world, simulator, god_console)
+    modal_health_warmer = _ModalHealthWarmer(_modal_health_targets(config))
+    handler = _build_handler(world, simulator, god_console, modal_health_warmer)
     address = (config.server.host, config.server.port)
     server = ThreadingHTTPServer(address, handler)
     print(f"God Simulator API listening on http://{config.server.host}:{config.server.port}")
@@ -41,6 +49,7 @@ def _build_handler(
     world: WorldState,
     simulator: WorldSimulator,
     god_console: GodConsole | None = None,
+    modal_health_warmer: _HealthWarmer | None = None,
 ) -> type[BaseHTTPRequestHandler]:
     lock = Lock()
     tick_status = _TickStatus()
@@ -55,7 +64,10 @@ def _build_handler(
             self.end_headers()
 
         def do_GET(self) -> None:
-            if self.path == "/health":
+            parsed_path = urlparse(self.path)
+            path = parsed_path.path
+
+            if path == "/health":
                 with lock:
                     payload = {
                         "status": "ok",
@@ -67,25 +79,31 @@ def _build_handler(
                 self._send_json(payload)
                 return
 
-            if self.path == "/state":
+            if path == "/state":
                 with lock:
                     payload = world.to_dict()
                     payload["simulation"] = _tick_status_payload(tick_status)
                 self._send_json(payload)
                 return
 
-            if self.path == "/claw3d/state":
+            if path == "/claw3d/state":
+                if modal_health_warmer is not None:
+                    query = parse_qs(parsed_path.query)
+                    if _truthy_query_value(query, "warmup"):
+                        modal_health_warmer.trigger(force=True)
                 with lock:
                     payload = to_claw3d_snapshot(
                         world,
                         tick_in_progress=tick_status.in_progress,
                         pending_tick=tick_status.pending_tick,
                     )
+                if modal_health_warmer is not None:
+                    payload["simulation"]["models"] = modal_health_warmer.statuses()
                 self._send_json(payload)
                 return
 
             self._send_json(
-                {"error": "not_found", "path": self.path},
+                {"error": "not_found", "path": path},
                 status=HTTPStatus.NOT_FOUND,
             )
 
@@ -296,3 +314,203 @@ def _tick_status_payload(tick_status: _TickStatus) -> dict[str, Any]:
         "tick_in_progress": tick_status.in_progress,
         "pending_tick": tick_status.pending_tick,
     }
+
+
+class _ModalHealthWarmer:
+    def __init__(
+        self,
+        targets: list[_ModalHealthTarget],
+        *,
+        cooldown_seconds: float = 300,
+        warmup_after_seconds: float = 2,
+        opener: _UrlOpener = urlopen,
+    ) -> None:
+        self._states = {
+            target.id: _ModalHealthState(target=target)
+            for target in targets
+        }
+        self._cooldown_seconds = cooldown_seconds
+        self._warmup_after_seconds = warmup_after_seconds
+        self._opener = opener
+        self._lock = Lock()
+
+    def trigger(self, *, force: bool = False) -> None:
+        if not self._states:
+            return
+
+        now = time.monotonic()
+        launches: list[tuple[str, str, int]] = []
+
+        with self._lock:
+            for target_id, state in self._states.items():
+                if state.in_progress:
+                    continue
+                if (
+                    not force
+                    and (
+                        now - state.last_started_at < self._cooldown_seconds
+                    )
+                ):
+                    continue
+                state.in_progress = True
+                state.status = "checking"
+                state.http_status = None
+                state.last_started_at = now
+                state.generation += 1
+                launches.append((target_id, state.target.health_url, state.generation))
+
+        for target_id, health_url, generation in launches:
+            Thread(
+                target=self._mark_warmup_if_pending,
+                args=(target_id, generation),
+                name="modal-health-warmup-status",
+                daemon=True,
+            ).start()
+            Thread(
+                target=self._run_one,
+                args=(target_id, health_url, generation),
+                name="modal-health-warmer",
+                daemon=True,
+            ).start()
+
+    def statuses(self) -> list[dict[str, Any]]:
+        with self._lock:
+            return [
+                {
+                    "id": state.target.id,
+                    "label": state.target.label,
+                    "model": state.target.model,
+                    "status": state.status,
+                    "http_status": state.http_status,
+                }
+                for state in self._states.values()
+            ]
+
+    def _mark_warmup_if_pending(self, target_id: str, generation: int) -> None:
+        time.sleep(self._warmup_after_seconds)
+        with self._lock:
+            state = self._states.get(target_id)
+            if (
+                state is not None
+                and state.generation == generation
+                and state.in_progress
+                and state.status == "checking"
+            ):
+                state.status = "warmup"
+
+    def _run_one(self, target_id: str, health_url: str, generation: int) -> None:
+        try:
+            response = self._opener(health_url)
+            try:
+                http_status = int(getattr(response, "status", 0))
+                self._set_status(
+                    target_id,
+                    generation,
+                    "ready" if http_status == 200 else "error",
+                    http_status,
+                )
+                print(
+                    f"Modal health check warmed {health_url}: {http_status}",
+                    flush=True,
+                )
+            finally:
+                response.close()
+        except (HTTPError, TimeoutError, URLError, OSError) as exc:
+            self._set_status(target_id, generation, "error", None)
+            print(f"Modal health check failed for {health_url}: {exc}", flush=True)
+
+    def _set_status(
+        self,
+        target_id: str,
+        generation: int,
+        status: str,
+        http_status: int | None,
+    ) -> None:
+        with self._lock:
+            state = self._states.get(target_id)
+            if state is None or state.generation != generation:
+                return
+            state.status = status
+            state.http_status = http_status
+            state.in_progress = False
+
+
+@dataclass(frozen=True, slots=True)
+class _ModalHealthTarget:
+    id: str
+    label: str
+    model: str | None
+    health_url: str
+
+
+@dataclass(slots=True)
+class _ModalHealthState:
+    target: _ModalHealthTarget
+    status: str = "unknown"
+    http_status: int | None = None
+    last_started_at: float = 0.0
+    generation: int = 0
+    in_progress: bool = False
+
+
+class _UrlResponse(Protocol):
+    status: int
+
+    def close(self) -> None: ...
+
+
+class _UrlOpener(Protocol):
+    def __call__(self, url: str) -> _UrlResponse: ...
+
+
+class _HealthWarmer(Protocol):
+    def trigger(self, *, force: bool = False) -> None: ...
+
+    def statuses(self) -> list[dict[str, Any]]: ...
+
+
+def _modal_health_urls(config: GameConfig) -> list[str]:
+    return [target.health_url for target in _modal_health_targets(config)]
+
+
+def _modal_health_targets(config: GameConfig) -> list[_ModalHealthTarget]:
+    targets: list[_ModalHealthTarget] = []
+    for target_id, label, connector in (
+        ("npc_model", "NPC model", config.connector),
+        ("god_console", "God Console", config.god_console),
+    ):
+        if connector is None:
+            continue
+        health_url = _modal_health_url(connector)
+        if health_url is not None:
+            targets.append(
+                _ModalHealthTarget(
+                    id=target_id,
+                    label=label,
+                    model=connector.model,
+                    health_url=health_url,
+                )
+            )
+    return targets
+
+
+def _modal_health_url(connector: ConnectorConfig) -> str | None:
+    if connector.type != "openai_compatible":
+        return None
+
+    root = connector.base_url or connector.api_url
+    if not root:
+        return None
+
+    root = root.strip().rstrip("/")
+    for suffix in ("/v1/chat/completions", "/chat/completions", "/v1"):
+        if root.endswith(suffix):
+            root = root.removesuffix(suffix)
+
+    if ".modal.run" not in root:
+        return None
+    return f"{root}/health"
+
+
+def _truthy_query_value(query: dict[str, list[str]], key: str) -> bool:
+    return any(value.lower() in ("1", "true", "yes") for value in query.get(key, []))

src/god_simulator/config.py

@@ -42,6 +42,10 @@ class ConnectorConfig:
     model: str | None = None
     api_key_env: str | None = None
     timeout_seconds: int = 60
+    max_tokens: int = 1400
+    temperature: float = 0.6
+    top_p: float = 0.95
+    tool_choice: str | dict[str, Any] | None = None
     max_parallel_npc_calls: int = 5
     fallback_to_deterministic: bool = True
     extra_body: dict[str, Any] | None = None
@@ -56,6 +60,7 @@ class GameConfig:
     connector: ConnectorConfig = field(
         default_factory=lambda: ConnectorConfig(type="deterministic")
     )
+    god_console: ConnectorConfig | None = None
 
 
 def load_game_config(path: Path) -> GameConfig:
@@ -71,6 +76,7 @@ def parse_game_config(raw: dict[str, Any]) -> GameConfig:
     simulation = _required_mapping(raw, "simulation")
     server = _required_mapping(raw, "server")
     connector = _optional_mapping(raw, "connector") or {"type": "deterministic"}
+    god_console = _optional_mapping(raw, "god_console")
 
     terrain_raw = _required_str(world, "terrain")
     if terrain_raw != "plain_green":
@@ -91,6 +97,7 @@ def parse_game_config(raw: dict[str, Any]) -> GameConfig:
             port=_required_positive_int(server, "port"),
         ),
         connector=_parse_connector_config(connector),
+        god_console=_parse_connector_config(god_console) if god_console else None,
     )
 
 
@@ -119,6 +126,9 @@ def _parse_connector_config(raw: dict[str, Any]) -> ConnectorConfig:
     if model_env:
         model = os.getenv(model_env) or model
 
+    temperature = _optional_non_negative_float(raw, "temperature")
+    top_p = _optional_probability(raw, "top_p")
+
     return ConnectorConfig(
         type=connector_type,
         base_url=base_url,
@@ -126,6 +136,10 @@ def _parse_connector_config(raw: dict[str, Any]) -> ConnectorConfig:
         model=model,
         api_key_env=_optional_str(raw, "api_key_env"),
         timeout_seconds=_optional_positive_int(raw, "timeout_seconds") or 60,
+        max_tokens=_optional_positive_int(raw, "max_tokens") or 1400,
+        temperature=0.6 if temperature is None else temperature,
+        top_p=0.95 if top_p is None else top_p,
+        tool_choice=_optional_tool_choice(raw, "tool_choice"),
         max_parallel_npc_calls=_optional_positive_int(raw, "max_parallel_npc_calls") or 5,
         fallback_to_deterministic=_optional_bool(raw, "fallback_to_deterministic", default=True),
         extra_body=_optional_mapping(raw, "extra_body"),
@@ -180,6 +194,28 @@ def _optional_positive_int(raw: dict[str, Any], key: str) -> int | None:
     return value
 
 
+def _optional_non_negative_float(raw: dict[str, Any], key: str) -> float | None:
+    value = raw.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, int | float) or isinstance(value, bool):
+        raise ValueError(f"Expected '{key}' to be a number.")
+    if value < 0:
+        raise ValueError(f"Expected '{key}' to be non-negative.")
+    return float(value)
+
+
+def _optional_probability(raw: dict[str, Any], key: str) -> float | None:
+    value = raw.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, int | float) or isinstance(value, bool):
+        raise ValueError(f"Expected '{key}' to be a number.")
+    if value <= 0 or value > 1:
+        raise ValueError(f"Expected '{key}' to be between 0 and 1.")
+    return float(value)
+
+
 def _required_str(raw: dict[str, Any], key: str) -> str:
     value = raw.get(key)
     if not isinstance(value, str) or not value:
@@ -205,6 +241,19 @@ def _optional_bool(raw: dict[str, Any], key: str, *, default: bool) -> bool:
     return value
 
 
+def _optional_tool_choice(raw: dict[str, Any], key: str) -> str | dict[str, Any] | None:
+    value = raw.get(key)
+    if value is None:
+        return None
+    if isinstance(value, str):
+        if not value:
+            raise ValueError(f"Expected '{key}' to be a non-empty string or object.")
+        return value
+    if isinstance(value, dict):
+        return value
+    raise ValueError(f"Expected '{key}' to be a string or object.")
+
+
 def _load_dotenv_for_config(config_path: Path) -> None:
     candidates = [
         Path.cwd() / ".env",

src/god_simulator/domain.py

@@ -29,6 +29,7 @@ class Npc:
     personality: str = "neutral"
     god_directive: str | None = None
     intention: str = "idle"
+    memory_summary: str | None = None
     memory: list[MemoryEntry] = field(default_factory=list)
 
 

src/god_simulator/rendering/claw3d_contract.py

@@ -52,6 +52,7 @@ def to_claw3d_snapshot(
                     "god_directive": npc.god_directive,
                     "is_alive": is_alive(npc),
                     "memory_count": len(npc.memory),
+                    "memory_summary": npc.memory_summary,
                     "memories": [
                         {
                             "tick": memory.tick,

src/god_simulator/simulation/connectors/deterministic.py

@@ -32,7 +32,6 @@ class DeterministicWorldSimulator:
                     npc_id=npc.id,
                     action="walk",
                     target=target,
-                    memory=f"{npc.name} kept exploring." if next_tick % 10 == 0 else None,
                 )
             )
 

src/god_simulator/simulation/connectors/openai_compatible.py

@@ -21,12 +21,12 @@ from god_simulator.simulation.mechanics import (
     BLOCK_SIZE,
     GRID_BLOCKS,
     MAX_WALK_DISTANCE,
-    NPC_COLLISION_RADIUS,
     TALK_RADIUS,
     VISIBLE_RADIUS,
     distance_between,
     is_alive,
 )
+from god_simulator.simulation.memory import recent_meaningful_memories
 
 ChatCompleter = Callable[[dict[str, Any]], dict[str, Any]]
 
@@ -250,9 +250,12 @@ class OpenAICompatibleWorldSimulator:
             "model": self._config.model,
             "messages": _build_messages(world, next_tick, npc),
             "tools": ACTION_TOOLS,
-            "temperature": 0.7,
-            "max_tokens": 1400,
+            "temperature": self._config.temperature,
+            "top_p": self._config.top_p,
+            "max_tokens": self._config.max_tokens,
         }
+        if self._config.tool_choice is not None:
+            request["tool_choice"] = self._config.tool_choice
         if self._config.extra_body:
             request["extra_body"] = self._config.extra_body
 
@@ -278,9 +281,10 @@ def _build_messages(
             "role": "system",
             "content": (
                 f"You are {npc.name}, a {npc.role} in a small civilization sandbox. "
-                "Choose your own next action from your current state and observations. "
-                "Use exactly one walk, talk, or attack tool call. For talk, the message "
-                "argument is the exact words you say aloud."
+                "Choose only your own next action from your current state and observations. "
+                "Use exactly one provided tool: walk, talk, or attack. Do not write prose, "
+                "JSON, narration, or reasoning text. For talk, the message argument is "
+                "the exact words you say aloud."
             ),
         },
         {
@@ -293,19 +297,9 @@ def _build_messages(
                         "observable_other_npcs_field": "visible_npcs",
                     },
                     "task": (
-                        "Choose the next action for this NPC only. Other NPCs are known "
-                        "only through visible_npcs. If tool calls are unavailable, return "
-                        "JSON with a single action object."
+                        "Choose one immediate action for this NPC only. Other NPCs are "
+                        "known only through visible_npcs. Call exactly one tool."
                     ),
-                    "fallback_json_schema": {
-                        "action": {
-                            "action": "walk | talk | attack",
-                            "npc_id": npc.id,
-                            "target": {"x": 0.0, "z": 0.0},
-                            "target_npc_id": "npc-002",
-                            "message": "exact words spoken for talk",
-                        }
-                    },
                     "rules": [
                         f"x must be between {-half_width} and {half_width}",
                         f"z must be between {-half_depth} and {half_depth}",
@@ -314,8 +308,6 @@ def _build_messages(
                         "prefer target coordinates at block centers",
                         "do not invent npc ids",
                         f"walk moves at most {MAX_WALK_DISTANCE:g} world units per tick",
-                        "NPC centers must stay at least "
-                        f"{NPC_COLLISION_RADIUS:g} world units apart",
                         f"talk requires target distance <= {TALK_RADIUS:g} world units",
                         f"attack requires target distance <= {ATTACK_RADIUS:g} world units",
                         f"each NPC can see only visible_npcs within {VISIBLE_RADIUS:g} world units",
@@ -357,12 +349,13 @@ def _npc_context(world: WorldState, npc: Npc) -> dict[str, Any]:
         "personality": npc.personality,
         "god_directive": npc.god_directive,
         "intention": npc.intention,
+        "memory_summary": npc.memory_summary,
         "recent_observations": [
             {
                 "tick": memory.tick,
                 "text": memory.text,
             }
-            for memory in npc.memory[-5:]
+            for memory in recent_meaningful_memories(npc)
         ],
         "visible_npcs": _visible_npc_summaries(world, npc),
     }

src/god_simulator/simulation/god_console.py

@@ -9,7 +9,8 @@ from typing import Any, cast
 from openai import OpenAI
 
 from god_simulator.config import ConnectorConfig
-from god_simulator.domain import MemoryEntry, Vec3, WorldState
+from god_simulator.domain import Vec3, WorldState
+from god_simulator.simulation.memory import recent_meaningful_memories, remember
 
 GodChatCompleter = Callable[[dict[str, Any]], dict[str, Any]]
 
@@ -157,9 +158,12 @@ class GodConsole:
             "model": self._config.model,
             "messages": _build_messages(world, command),
             "tools": GOD_TOOLS,
-            "temperature": 0.2,
-            "max_tokens": 1200,
+            "temperature": self._config.temperature,
+            "top_p": self._config.top_p,
+            "max_tokens": self._config.max_tokens,
         }
+        if isinstance(self._config.tool_choice, str):
+            request["tool_choice"] = self._config.tool_choice
         if self._config.extra_body:
             request["extra_body"] = self._config.extra_body
 
@@ -213,15 +217,13 @@ def apply_god_command_plan(world: WorldState, plan: GodCommandPlan) -> list[str]
                 if directive is None:
                     continue
                 npc.god_directive = directive
-                npc.memory.append(MemoryEntry(tick=world.tick, text=f"God directive: {directive}"))
-                del npc.memory[:-20]
+                remember(npc, world.tick, f"God directive: {directive}")
                 applied.append(f"{npc.name} directive set.")
             case "add_npc_memory":
                 memory = _short_text(edit.arguments.get("memory"), limit=240)
                 if memory is None:
                     continue
-                npc.memory.append(MemoryEntry(tick=world.tick, text=memory))
-                del npc.memory[:-20]
+                remember(npc, world.tick, memory)
                 applied.append(f"{npc.name} memory added.")
             case "set_npc_position":
                 x = _float_arg(edit.arguments.get("x"))
@@ -272,7 +274,11 @@ def _build_messages(world: WorldState, command: str) -> list[dict[str, str]]:
                             "personality": npc.personality,
                             "god_directive": npc.god_directive,
                             "intention": npc.intention,
-                            "recent_memories": [memory.text for memory in npc.memory[-3:]],
+                            "memory_summary": npc.memory_summary,
+                            "recent_memories": [
+                                memory.text
+                                for memory in recent_meaningful_memories(npc, limit=3)
+                            ],
                         }
                         for npc in world.npcs
                     ],

src/god_simulator/simulation/mechanics.py

@@ -11,7 +11,6 @@ ATTACK_RADIUS = 1.0 * BLOCK_SIZE
 TALK_RADIUS = 3.0 * BLOCK_SIZE
 VISIBLE_RADIUS = 5.0 * BLOCK_SIZE
 MAX_WALK_DISTANCE = 1.0 * BLOCK_SIZE
-NPC_COLLISION_RADIUS = 0.2 * BLOCK_SIZE
 
 
 def is_alive(npc: Npc) -> bool:

src/god_simulator/simulation/memory.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from god_simulator.domain import MemoryEntry, Npc
+
+RECENT_MEMORY_LIMIT = 5
+MEMORY_SUMMARY_LIMIT = 900
+
+
+def remember(npc: Npc, tick: int, text: str) -> None:
+    if _is_routine_memory(text):
+        return
+
+    npc.memory.append(MemoryEntry(tick=tick, text=text))
+    compact_memory(npc)
+
+
+def compact_memory(npc: Npc) -> None:
+    meaningful_memories = [
+        memory for memory in npc.memory if not _is_routine_memory(memory.text)
+    ]
+    if len(meaningful_memories) <= RECENT_MEMORY_LIMIT:
+        npc.memory = meaningful_memories
+        return
+
+    older_memories = meaningful_memories[:-RECENT_MEMORY_LIMIT]
+    npc.memory = meaningful_memories[-RECENT_MEMORY_LIMIT:]
+    npc.memory_summary = _merge_summary(npc.memory_summary, older_memories)
+
+
+def recent_meaningful_memories(npc: Npc, *, limit: int = RECENT_MEMORY_LIMIT) -> list[MemoryEntry]:
+    return [
+        memory for memory in npc.memory if not _is_routine_memory(memory.text)
+    ][-limit:]
+
+
+def _merge_summary(previous_summary: str | None, older_memories: list[MemoryEntry]) -> str:
+    fragments = []
+    if previous_summary:
+        fragments.append(previous_summary)
+    fragments.extend(f"Tick {memory.tick}: {memory.text}" for memory in older_memories)
+
+    summary = " ".join(" ".join(fragments).split())
+    if len(summary) <= MEMORY_SUMMARY_LIMIT:
+        return summary
+    return "..." + summary[-(MEMORY_SUMMARY_LIMIT - 3) :]
+
+
+def _is_routine_memory(text: str) -> bool:
+    return (
+        text == "You waited."
+        or text.startswith("You moved to x ")
+        or text.endswith(" kept exploring.")
+    )

src/god_simulator/simulation/tick.py

@@ -3,18 +3,18 @@ from __future__ import annotations
 import math
 import random
 
-from god_simulator.domain import MemoryEntry, Npc, Vec3, WorldState
+from god_simulator.domain import Npc, Vec3, WorldState
 from god_simulator.simulation.connectors.base import NpcDirective, TickPlan, WorldSimulator
 from god_simulator.simulation.connectors.deterministic import DeterministicWorldSimulator
 from god_simulator.simulation.mechanics import (
     ATTACK_RADIUS,
     BLOCK_SIZE,
     MAX_WALK_DISTANCE,
-    NPC_COLLISION_RADIUS,
     TALK_RADIUS,
     distance_between,
     is_alive,
 )
+from god_simulator.simulation.memory import remember
 
 
 def advance_world(world: WorldState, simulator: WorldSimulator | None = None) -> WorldState:
@@ -40,7 +40,7 @@ def apply_tick_plan(world: WorldState, next_tick: int, plan: TickPlan) -> None:
     half_width = world.terrain.width / 2
     half_depth = world.terrain.depth / 2
     npcs_by_id = {npc.id: npc for npc in world.npcs}
-    walk_targets, blocked_walkers = _resolve_walk_targets(
+    walk_targets = _resolve_walk_targets(
         world,
         plan.directives,
         half_width=half_width,
@@ -60,13 +60,6 @@ def apply_tick_plan(world: WorldState, next_tick: int, plan: TickPlan) -> None:
             case "walk":
                 if not directive.target:
                     _apply_walk(npc, None, next_tick)
-                elif npc.id in blocked_walkers:
-                    npc.intention = "blocked"
-                    _append_memory(
-                        npc,
-                        next_tick,
-                        "You could not move because the destination was occupied.",
-                    )
                 else:
                     _apply_walk(npc, walk_targets.get(npc.id), next_tick)
             case "talk":
@@ -77,7 +70,7 @@ def apply_tick_plan(world: WorldState, next_tick: int, plan: TickPlan) -> None:
                 npc.intention = "idle"
 
         if directive.memory:
-            _append_memory(npc, next_tick, directive.memory)
+            remember(npc, next_tick, directive.memory)
 
     for npc in world.npcs:
         if not is_alive(npc):
@@ -93,9 +86,9 @@ def _resolve_walk_targets(
     *,
     half_width: float,
     half_depth: float,
-) -> tuple[dict[str, Vec3], set[str]]:
+) -> dict[str, Vec3]:
     npcs_by_id = {npc.id: npc for npc in world.npcs}
-    candidates: dict[str, Vec3] = {}
+    targets: dict[str, Vec3] = {}
 
     for directive in directives:
         if directive.action != "walk" or not directive.target:
@@ -105,30 +98,14 @@ def _resolve_walk_targets(
         if not npc or not is_alive(npc):
             continue
 
-        candidates[npc.id] = _planned_walk_target(
+        targets[npc.id] = _planned_walk_target(
             npc,
             directive.target,
             half_width=half_width,
             half_depth=half_depth,
         )
 
-    blocked = {
-        npc_id
-        for npc_id, target in candidates.items()
-        if _collides_with_current_position(npcs_by_id[npc_id], target, world.npcs)
-    }
-
-    candidate_items = list(candidates.items())
-    for index, (first_id, first_target) in enumerate(candidate_items):
-        for second_id, second_target in candidate_items[index + 1 :]:
-            if _positions_too_close(first_target, second_target):
-                blocked.add(first_id)
-                blocked.add(second_id)
-
-    return (
-        {npc_id: target for npc_id, target in candidates.items() if npc_id not in blocked},
-        blocked,
-    )
+    return targets
 
 
 def _planned_walk_target(
@@ -159,23 +136,10 @@ def _planned_walk_target(
 def _apply_walk(npc: Npc, target: Vec3 | None, next_tick: int) -> None:
     if target is None:
         npc.intention = "idle"
-        _append_memory(npc, next_tick, "You waited.")
         return
 
     npc.position = target
     npc.intention = "walking"
-    _append_memory(npc, next_tick, f"You moved to x {target.x:.1f}, z {target.z:.1f}.")
-
-
-def _collides_with_current_position(npc: Npc, target: Vec3, npcs: list[Npc]) -> bool:
-    return any(
-        other.id != npc.id and _positions_too_close(target, other.position)
-        for other in npcs
-    )
-
-
-def _positions_too_close(first: Vec3, second: Vec3) -> bool:
-    return math.hypot(first.x - second.x, first.z - second.z) < NPC_COLLISION_RADIUS
 
 
 def _apply_talk(
@@ -187,18 +151,18 @@ def _apply_talk(
     target = npcs_by_id.get(directive.target_npc_id or "")
     if not target or target.id == npc.id or not is_alive(target):
         npc.intention = "could not talk"
-        _append_memory(npc, next_tick, "You could not talk because the target was unavailable.")
+        remember(npc, next_tick, "You could not talk because the target was unavailable.")
         return
 
     if distance_between(npc, target) > TALK_RADIUS:
         npc.intention = f"too far to talk to {target.name}"
-        _append_memory(npc, next_tick, f"You were too far away to talk to {target.name}.")
+        remember(npc, next_tick, f"You were too far away to talk to {target.name}.")
         return
 
     message = directive.message or "checking in"
     npc.intention = f"talking to {target.name}"
-    _append_memory(npc, next_tick, f"You told {target.name}: {message}")
-    _append_memory(target, next_tick, f"{npc.name} told you: {message}")
+    remember(npc, next_tick, f"You told {target.name}: {message}")
+    remember(target, next_tick, f"{npc.name} told you: {message}")
 
 
 def _apply_attack(
@@ -211,29 +175,24 @@ def _apply_attack(
     target = npcs_by_id.get(directive.target_npc_id or "")
     if not target or target.id == npc.id or not is_alive(target):
         npc.intention = "could not attack"
-        _append_memory(npc, next_tick, "You could not attack because the target was unavailable.")
+        remember(npc, next_tick, "You could not attack because the target was unavailable.")
         return
 
     if distance_between(npc, target) > ATTACK_RADIUS:
         npc.intention = f"too far to attack {target.name}"
-        _append_memory(npc, next_tick, f"You were too far away to attack {target.name}.")
+        remember(npc, next_tick, f"You were too far away to attack {target.name}.")
         return
 
     rng = random.Random(f"{world.seed}:{next_tick}:{npc.id}:attack:{target.id}")
     damage = npc.attack_damage + rng.randint(0, 5)
     target.health -= damage
     npc.intention = f"attacking {target.name}"
-    _append_memory(npc, next_tick, f"You attacked {target.name} for {damage} damage.")
-    _append_memory(target, next_tick, f"{npc.name} attacked you for {damage} damage.")
+    remember(npc, next_tick, f"You attacked {target.name} for {damage} damage.")
+    remember(target, next_tick, f"{npc.name} attacked you for {damage} damage.")
 
     if not is_alive(target):
         target.intention = "dead"
-        _append_memory(target, next_tick, "You died.")
-
-
-def _append_memory(npc: Npc, tick: int, text: str) -> None:
-    npc.memory.append(MemoryEntry(tick=tick, text=text))
-    del npc.memory[:-20]
+        remember(target, next_tick, "You died.")
 
 
 def _clamp(value: float, minimum: float, maximum: float) -> float:

tests/e2e/god-simulator-scene.spec.ts

@@ -89,6 +89,7 @@ test("shows tooltips only for collapsed text labels", async ({ page }) => {
               god_directive: null,
               is_alive: true,
               memory_count: 1,
+              memory_summary: null,
               memories: [{ tick: 0, text: "Lena arrived as a builder." }],
             },
             render: {

tests/test_api_server.py

@@ -3,11 +3,23 @@ from __future__ import annotations
 import json
 from http.client import HTTPConnection
 from http.server import ThreadingHTTPServer
-from threading import Event, Thread
+from threading import Event, Lock, Thread
 from typing import Any
 
-from god_simulator.api.server import _build_handler
-from god_simulator.config import GameConfig, NpcConfig, ServerConfig, SimulationConfig, WorldConfig
+from god_simulator.api.server import (
+    _build_handler,
+    _modal_health_urls,
+    _ModalHealthTarget,
+    _ModalHealthWarmer,
+)
+from god_simulator.config import (
+    ConnectorConfig,
+    GameConfig,
+    NpcConfig,
+    ServerConfig,
+    SimulationConfig,
+    WorldConfig,
+)
 from god_simulator.domain import WorldState
 from god_simulator.simulation.connectors.base import TickPlan
 from god_simulator.simulation.spawning import create_world
@@ -64,6 +76,139 @@ def test_snapshot_returns_previous_world_while_tick_is_planning() -> None:
         server_thread.join(timeout=1)
 
 
+def test_snapshot_triggers_modal_health_warmup() -> None:
+    world = create_world(_config(npc_count=2))
+    warmer = _FakeHealthWarmer()
+    server = ThreadingHTTPServer(
+        ("127.0.0.1", 0),
+        _build_handler(world, _SlowSimulator(), modal_health_warmer=warmer),
+    )
+    port = int(server.server_address[1])
+    server_thread = Thread(target=server.serve_forever, daemon=True)
+
+    server_thread.start()
+    try:
+        status, snapshot = _request_json(port, "GET", "/claw3d/state?warmup=1", timeout=1)
+
+        assert status == 200
+        assert snapshot["tick"] == 0
+        assert snapshot["simulation"]["models"] == [
+            {
+                "id": "npc_model",
+                "label": "NPC model",
+                "model": "test-model",
+                "status": "ready",
+                "http_status": 200,
+            }
+        ]
+        assert warmer.trigger_count == 1
+
+        status, _ = _request_json(port, "GET", "/health", timeout=1)
+
+        assert status == 200
+        assert warmer.trigger_count == 1
+    finally:
+        server.shutdown()
+        server.server_close()
+        server_thread.join(timeout=1)
+
+
+def test_snapshot_without_warmup_query_only_reads_model_status() -> None:
+    world = create_world(_config(npc_count=2))
+    warmer = _FakeHealthWarmer()
+    server = ThreadingHTTPServer(
+        ("127.0.0.1", 0),
+        _build_handler(world, _SlowSimulator(), modal_health_warmer=warmer),
+    )
+    port = int(server.server_address[1])
+    server_thread = Thread(target=server.serve_forever, daemon=True)
+
+    server_thread.start()
+    try:
+        status, snapshot = _request_json(port, "GET", "/claw3d/state", timeout=1)
+
+        assert status == 200
+        assert snapshot["simulation"]["models"][0]["status"] == "ready"
+        assert warmer.trigger_count == 0
+    finally:
+        server.shutdown()
+        server.server_close()
+        server_thread.join(timeout=1)
+
+
+def test_modal_health_urls_use_only_modal_openai_connectors() -> None:
+    config = _config(
+        npc_count=2,
+        connector=ConnectorConfig(
+            type="openai_compatible",
+            base_url="https://workspace--npc-serve.modal.run/v1",
+            model="npc-model",
+        ),
+        god_console=ConnectorConfig(
+            type="openai_compatible",
+            base_url="https://workspace--god-serve.modal.run/v1/chat/completions",
+            model="god-model",
+        ),
+    )
+
+    assert _modal_health_urls(config) == [
+        "https://workspace--npc-serve.modal.run/health",
+        "https://workspace--god-serve.modal.run/health",
+    ]
+
+    config = _config(
+        npc_count=2,
+        connector=ConnectorConfig(
+            type="openai_compatible",
+            base_url="https://workspace--npc-serve.modal.run/v1",
+            model="npc-model",
+        ),
+        god_console=ConnectorConfig(
+            type="openai_compatible",
+            base_url="https://openrouter.ai/api/v1",
+            model="external-model",
+        ),
+    )
+
+    assert _modal_health_urls(config) == [
+        "https://workspace--npc-serve.modal.run/health"
+    ]
+
+
+def test_forced_modal_warmup_does_not_duplicate_inflight_checks() -> None:
+    opener = _BlockingOpener()
+    warmer = _ModalHealthWarmer(
+        [
+            _ModalHealthTarget(
+                id="npc_model",
+                label="NPC model",
+                model="test-model",
+                health_url="https://workspace--npc-serve.modal.run/health",
+            )
+        ],
+        opener=opener,
+    )
+
+    warmer.trigger(force=True)
+    assert opener.started.wait(timeout=1)
+    warmer.trigger(force=True)
+
+    statuses = warmer.statuses()
+    try:
+        assert opener.call_count == 1
+        assert statuses == [
+            {
+                "id": "npc_model",
+                "label": "NPC model",
+                "model": "test-model",
+                "status": "checking",
+                "http_status": None,
+            }
+        ]
+    finally:
+        opener.release.set()
+
+
 class _SlowSimulator:
     name = "slow"
 
@@ -77,6 +222,48 @@ class _SlowSimulator:
         return TickPlan(source=self.name, directives=[])
 
 
+class _FakeHealthWarmer:
+    def __init__(self) -> None:
+        self.trigger_count = 0
+
+    def trigger(self, *, force: bool = False) -> None:
+        self.trigger_count += 1
+
+    def statuses(self) -> list[dict[str, Any]]:
+        return [
+            {
+                "id": "npc_model",
+                "label": "NPC model",
+                "model": "test-model",
+                "status": "ready",
+                "http_status": 200,
+            }
+        ]
+
+
+class _BlockingOpener:
+    def __init__(self) -> None:
+        self.started = Event()
+        self.release = Event()
+        self._lock = Lock()
+        self.call_count = 0
+
+    def __call__(self, url: str) -> Any:
+        _ = url
+        with self._lock:
+            self.call_count += 1
+        self.started.set()
+        self.release.wait(timeout=5)
+        return _FakeResponse()
+
+
+class _FakeResponse:
+    status: int = 200
+
+    def close(self) -> None:
+        return
+
+
 def _request_json(
     port: int,
     method: str,
@@ -97,10 +284,17 @@ def _request_json(
     return response.status, payload
 
 
-def _config(*, npc_count: int) -> GameConfig:
+def _config(
+    *,
+    npc_count: int,
+    connector: ConnectorConfig | None = None,
+    god_console: ConnectorConfig | None = None,
+) -> GameConfig:
     return GameConfig(
         world=WorldConfig(width=80, depth=80, terrain="plain_green", seed=42),
         npcs=NpcConfig(count=npc_count),
         simulation=SimulationConfig(tick_ms=500),
         server=ServerConfig(host="127.0.0.1", port=8000),
+        connector=connector or ConnectorConfig(type="deterministic"),
+        god_console=god_console,
     )

tests/test_claw3d_contract.py

@@ -35,6 +35,7 @@ def test_claw3d_snapshot_contains_terrain_and_entities() -> None:
     assert snapshot["entities"][0]["state"]["personality"] == "neutral"
     assert snapshot["entities"][0]["state"]["god_directive"] is None
     assert snapshot["entities"][0]["state"]["memory_count"] == 1
+    assert snapshot["entities"][0]["state"]["memory_summary"] is None
     assert snapshot["entities"][0]["state"]["memories"] == [
         {"tick": 0, "text": "Ada arrived as a farmer."}
     ]

tests/test_config.py

@@ -35,15 +35,38 @@ def test_parse_openai_compatible_connector() -> None:
                 "type": "openai_compatible",
                 "base_url": "http://llm.local/v1",
                 "model": "test-model",
+                "max_tokens": 256,
+                "temperature": 0.6,
+                "top_p": 0.95,
+                "tool_choice": "required",
                 "max_parallel_npc_calls": 3,
             },
+            "god_console": {
+                "type": "openai_compatible",
+                "base_url": "https://georgij-sawin--god-simulator-qwen36-27b-h100-serve.modal.run/v1",
+                "model": "qwen3.6-27b-h100-fp8",
+                "max_tokens": 1200,
+                "tool_choice": "required",
+            },
         }
     )
 
     assert config.connector.type == "openai_compatible"
     assert config.connector.base_url == "http://llm.local/v1"
     assert config.connector.model == "test-model"
+    assert config.connector.max_tokens == 256
+    assert config.connector.temperature == 0.6
+    assert config.connector.top_p == 0.95
+    assert config.connector.tool_choice == "required"
     assert config.connector.max_parallel_npc_calls == 3
+    assert config.god_console is not None
+    assert (
+        config.god_console.base_url
+        == "https://georgij-sawin--god-simulator-qwen36-27b-h100-serve.modal.run/v1"
+    )
+    assert config.god_console.model == "qwen3.6-27b-h100-fp8"
+    assert config.god_console.max_tokens == 1200
+    assert config.god_console.tool_choice == "required"
 
 
 def test_rejects_negative_npc_count() -> None:

tests/test_god_console.py

@@ -79,6 +79,8 @@ def test_god_console_parses_tool_calls_and_applies_npc_edits() -> None:
     applied = apply_god_command_plan(world, plan)
 
     assert captured_request["model"] == "test-model"
+    assert captured_request["temperature"] == 0.6
+    assert captured_request["top_p"] == 0.95
     assert "tool_choice" not in captured_request
     assert plan.source == "openai_compatible"
     assert plan.summary == "Ada has been rewritten by divine command."

tests/test_openai_connector.py

@@ -68,6 +68,9 @@ def test_openai_connector_uses_tool_calls_for_npc_directives() -> None:
     advance_world(world, simulator)
 
     first_request = captured_requests[0]
+    assert first_request["max_tokens"] == 1400
+    assert first_request["temperature"] == 0.6
+    assert first_request["top_p"] == 0.95
     assert [tool["function"]["name"] for tool in first_request["tools"]] == [
         "walk",
         "talk",
@@ -82,10 +85,67 @@ def test_openai_connector_uses_tool_calls_for_npc_directives() -> None:
     assert payload["npc"]["id"] == "npc-001"
     assert payload["npc"]["health"] == 100
     assert "attack_damage" in payload["npc"]
+    assert "fallback_json_schema" not in payload
     assert world.npcs[0].position.x == 6
     assert world.npcs[0].position.z == 2
     assert world.npcs[0].intention == "walking"
-    assert world.npcs[0].memory[-1].text == "You moved to x 6.0, z 2.0."
+    assert [memory.text for memory in world.npcs[0].memory] == [
+        "Ada arrived as a farmer."
+    ]
+
+
+def test_openai_connector_uses_configured_max_tokens() -> None:
+    captured_requests: list[dict[str, Any]] = []
+
+    def fake_chat_completer(request: dict[str, Any]) -> dict[str, Any]:
+        captured_requests.append(request)
+        payload = json.loads(request["messages"][1]["content"])
+        npc_id = payload["npc"]["id"]
+        return {
+            "choices": [
+                {
+                    "message": {
+                        "tool_calls": [
+                            {
+                                "type": "function",
+                                "function": {
+                                    "name": "walk",
+                                    "arguments": json.dumps(
+                                        {
+                                            "npc_id": npc_id,
+                                            "target_x": 6,
+                                            "target_z": 2,
+                                        }
+                                    ),
+                                },
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+
+    world = create_world(_game_config(npc_count=1))
+    simulator = OpenAICompatibleWorldSimulator(
+        ConnectorConfig(
+            type="openai_compatible",
+            base_url="http://llm.local/v1",
+            model="test-model",
+            max_tokens=256,
+            temperature=0.2,
+            top_p=0.8,
+            tool_choice="required",
+        ),
+        fallback=DeterministicWorldSimulator(),
+        chat_completer=fake_chat_completer,
+    )
+
+    advance_world(world, simulator)
+
+    assert captured_requests[0]["max_tokens"] == 256
+    assert captured_requests[0]["temperature"] == 0.2
+    assert captured_requests[0]["top_p"] == 0.8
+    assert captured_requests[0]["tool_choice"] == "required"
 
 
 def test_openai_connector_calls_llm_on_every_tick() -> None:

tests/test_world_spawning.py

@@ -33,6 +33,7 @@ def test_tick_advances_world_without_leaving_terrain() -> None:
     assert all(-40 <= npc.position.x <= 40 for npc in world.npcs)
     assert all(-40 <= npc.position.z <= 40 for npc in world.npcs)
     assert {npc.intention for npc in world.npcs} == {"walking"}
+    assert all(len(npc.memory) == 1 for npc in world.npcs)
 
 
 def test_attack_damages_target_inside_one_block_radius() -> None:
@@ -114,6 +115,36 @@ def test_talk_adds_memory_inside_three_block_radius() -> None:
     assert "Hold this position." in listener.memory[-1].text
 
 
+def test_memory_keeps_recent_entries_and_summarizes_older_events() -> None:
+    world = create_world(_config(npc_count=2))
+    speaker, listener = world.npcs
+    speaker.position = Vec3(x=0.0, y=0.0, z=0.0)
+    listener.position = Vec3(x=0.0, y=0.0, z=3.0)
+
+    for tick in range(1, 8):
+        apply_tick_plan(
+            world,
+            tick,
+            TickPlan(
+                source="test",
+                directives=[
+                    NpcDirective(
+                        npc_id=speaker.id,
+                        action="talk",
+                        target_npc_id=listener.id,
+                        message=f"Message {tick}.",
+                    )
+                ],
+            ),
+        )
+
+    assert len(speaker.memory) == 5
+    assert speaker.memory_summary is not None
+    assert "Ada arrived as a farmer." in speaker.memory_summary
+    assert "Message 1." in speaker.memory_summary
+    assert "Message 7." in speaker.memory[-1].text
+
+
 def test_dead_npc_stays_in_place_and_cannot_act() -> None:
     world = create_world(_config(npc_count=2))
     dead, target = world.npcs
@@ -140,7 +171,7 @@ def test_dead_npc_stays_in_place_and_cannot_act() -> None:
     assert target.health == 100
 
 
-def test_two_npcs_cannot_walk_to_same_destination_in_one_tick() -> None:
+def test_two_npcs_can_walk_to_same_destination_in_one_tick() -> None:
     world = create_world(_config(npc_count=2))
     first, second = world.npcs
     first.position = Vec3(x=-2.0, y=0.0, z=2.0)
@@ -166,13 +197,13 @@ def test_two_npcs_cannot_walk_to_same_destination_in_one_tick() -> None:
         ),
     )
 
-    assert first.position == Vec3(x=-2.0, y=0.0, z=2.0)
-    assert second.position == Vec3(x=6.0, y=0.0, z=2.0)
-    assert first.intention == "blocked"
-    assert second.intention == "blocked"
+    assert first.position == Vec3(x=2.0, y=0.0, z=2.0)
+    assert second.position == Vec3(x=2.0, y=0.0, z=2.0)
+    assert first.intention == "walking"
+    assert second.intention == "walking"
 
 
-def test_npc_cannot_walk_into_occupied_position() -> None:
+def test_npc_can_walk_into_occupied_position() -> None:
     world = create_world(_config(npc_count=2))
     first, second = world.npcs
     first.position = Vec3(x=-2.0, y=0.0, z=2.0)
@@ -193,9 +224,9 @@ def test_npc_cannot_walk_into_occupied_position() -> None:
         ),
     )
 
-    assert first.position == Vec3(x=-2.0, y=0.0, z=2.0)
+    assert first.position == Vec3(x=2.0, y=0.0, z=2.0)
     assert second.position == Vec3(x=2.0, y=0.0, z=2.0)
-    assert first.intention == "blocked"
+    assert first.intention == "walking"
 
 
 def test_attack_that_drops_health_below_zero_marks_target_dead() -> None: