TaughtLocalLLM — context makes a weak model capable
A demo bench: the brain is taught the move-level Zork I solution — distilled from Claude Opus 4.8's own 350/350 run — and the weak local model
(gemma4:e4b, 4B, via Ollama) follows it in the live loop — a fork of the ZorkGPT orchestrator serves the
brain's taught move on every turn, while the 4B agent + reused ZorkGPT critic still run each turn.
Same engine as zorkgpt.com (Jericho zork1.z5, 0–350).
The weak 4B reached the full 350 in the live loop — about 35× its
unaided ~10, the complete game (egg → house → Cellar → troll → painting → temple coffin/sceptre/torch →
pray escape → bank → coal mine → all 19 treasures → Stone Barrow). The earlier ceiling (73 / 177) was
non-deterministic: the orchestrator invoked the brain's serving on only ~60% of turns, so the sequence-sensitive
lamp management desynced. The fix was to fork the orchestrator loop so the brain serves the taught move on
every turn, via an exception-safe self-pointer that advances only when a move is actually executed —
an LLM-failure turn can no longer skip a move. Result: 396/396 moves served 1:1, 0 errors, 350 reached exactly at
move 396 (the episode loop then ran on to its 500-turn cap with the unguided 4B wandering at the banked 350).
The 4B agent + ZorkGPT critic still run each turn; the brain forces the move at execution.
Reliable step-level context turns a 4B (unaided ~10) into a 350 — brain = intelligence, LLM = actuator.
Delivery reliability is the variable — isolated with a 240-trial sweep
The single intermittent run (73 / 177 / death) and the reliable run (350 / 350) are two points; to prove
the mechanism we sweep it. A no-LLM harness (replay_delivery_ablation.py) replays the
same 396-move taught solution and, each turn, drops the delivery with probability p under the two
pointer disciplines from the real loop — blind (a dropped turn still advances the pointer, so the move is
skipped: the pre-fix bug) vs safe (a dropped turn leaves the pointer untouched, so the move is
delayed, never skipped: the shipped fix). 30 seeded trials per cell:
| drop p | blind — score (mean±std) | blind — deaths | safe — score | safe — turns |
|---|---|---|---|---|
| 0 | 350 (det.) | 0% | 350 | 396 |
| 1% | 96.2 ± 89.6 | 43% | 350 ± 0 | 400 |
| 2% | 69.3 ± 50.7 | 67% | 350 ± 0 | 404 |
| 5% | 28.2 ± 27.9 | 40% | 350 ± 0 | 417 |
| 10% | 14.8 ± 13.0 | 33% | 350 ± 0 | 440 |
| 20% | 8.5 ± 10.4 | 20% | 350 ± 0 | 495 |
| 40% | 2.2 ± 3.8 | 10% | 350 ± 0 | 652 |
With a blind pointer, a 1% drop rate already collapses the mean to 96/350 and kills the agent in
43% of trials, and 350 is never reached at any non-zero rate — the historical 73/177 runs (≈40% of
turns served) sit inside this band. The exception-safe pointer is invariant: 350/350 in all 210 trials from 1%
to 40% drops, paying only in turns (396 → 652). And p < 1 is real for this 4B: unaided it emitted
94.9 JSON-malformed + 40.5 empty (context-saturated) completions per 100 turns before harness fixes drove
both to ≈0.1 — every one a turn a blind pointer would skip. Data: analysis/delivery_ablation.json,
analysis/failure-economy.md; digests in analysis/repro-manifest.json.
Why this matters
The same 4B that scores ~10 unaided here reaches the full solution — because the brain supplies step-level context (the next move) and the critic enforces it. This is the thesis in one bench: brain = intelligence, LLM = actuator; model size gates execution, not the strategy. And the solution itself is distilled from Claude Opus 4.8's 350/350 run: a frontier model solves the task once, the brain stores it, and a cheap 4B replays it indefinitely — distillation through memory, not weights, which saves frontier-inference cost on already-solved tasks. This is a demonstration bench only — the solution knowledge is taught for the demo and is not seeded into the AGI-purity bench (where the brain must discover, not be told).
Comparison
| Agent | Model | Score | Mode |
|---|---|---|---|
| TaughtLocalLLM | gemma4:e4b · 4B | 350 | brain taught the solution (from Opus 4.8's 350 run); orchestrator-fork serves it every turn |
| TerranSoul brain | gemma4:e4b · 4B | 10–20 | brain + harness, no taught solution |
| ZorkGPT ep120 | deepseek-v3.2+27B | 115 | frontier, best of 122 public eps |
| Opus 4.8 | frontier | real run → | genuine move-by-move play |
Replay (validation, first 16 moves)
turn 1 n score 0 turn 2 N score 0 turn 3 u score 0 turn 4 get egg score +5 -> 5 turn 5 d score 5 turn 6 S score 5 turn 7 E score 5 turn 8 open window score 5 turn 9 W score +10 -> 15 (enter house) ... turn 60 (on the canonical curve) score 63
The live in-loop run served all 396 taught moves (1:1, 0 errors) and reached 350 exactly at move 396;
the deterministic no-LLM check (play_zork.py) replays the same sequence to 350. Full transcript + score curve recorded with the run.