Train in phases, starting with power word traces for fast structural convergence, then transitioning to normal NL traces for higher ceiling.
- Phase 1 (0-3K steps): power word traces — learn reasoning structure fast
- Phase 2 (3K-6K steps): mixed 50/50 — bridge from structured to natural
- Phase 3 (6K+): normal traces — full NL, structure internalized
- Implementation: generate three datasets up front, swap dataloader at phase boundaries
- Hypothesis: reach normal's ceiling at power's convergence speed
- Connects to Vygotsky scaffolding — training wheels that get removed
Train the model to emit a power word and then expand it into natural language. GIVEN → "we know that...", APPLY → "using this rule since... then..." The power word is a compressed function call, the prose is the execution. Tests whether the model can learn power words as triggers for expanded reasoning rather than just syntactic labels. Partially implemented in mixed mode bridge format but not isolated as its own test.
Instead of hand-designing power words, add blank special tokens (semantically empty) and train with RL. Let the model discover what control signals it needs. Whatever those tokens come to mean is whatever the model needed to tell itself. Eliminates the question of whether WE chose the right vocabulary. Requires RL infrastructure we haven't built.
Current implementation compares rolling avg to prior window. User's stock chaser concept: assign a cost to each iteration, stop when incremental cost exceeds marginal improvement. Could formalize as: stop when (improvement_per_step / compute_cost_per_step) falls below threshold. Currently using simpler plateau detection which works but isn't optimal.
Two-phase approach:
- Screen: 20K data, 5K steps, ~3 min. Rank candidates, check trajectory.
- Validate: 50K data, plateau detection, ~15 min. Only top candidates.
Report two metrics always:
- Convergence speed (steps to 80%)
- Ceiling (rolling avg at convergence) Calculate token budget per format BEFORE any run. No more truncation.
Current: 5M params (6L 8H 256D). Could try:
- 10M: 8L 8H 320D — does self-modulation emerge at larger scale?
- 2M: 4L 4H 192D — does power word advantage increase when model is smaller? The attention probing showed no self-modulation at 5M. The question is whether that's a fundamental limit or a scale issue.
Replace or supplement synthetic data with actual GSM8K or PrOntoQA datasets. Tests whether findings generalize beyond our synthetic generator. Risk: our word-level tokenizer can't handle real English vocabulary — would need BPE.
Instead of blanket VERIFY after every step (selfcheck — which was neutral), use
targeted reflection: reason forward normally, produce an answer, then check if
the answer makes sense. Only re-engage if something looks wrong. This is the
Reflexion paper approach (arxiv 2303.11366). The key difference from selfcheck:
selfcheck verifies every step (wasteful), reflexion verifies the conclusion
(targeted). Could be implemented as:
<think> [reasoning] </think> <speak> [answer] </speak> <reflect> [is this right?] </reflect>
If reflection triggers doubt, the model re-enters thinking.
More like a human saying "wait, that doesn't sound right" after speaking.
Think/speak achieved 91.2% — best non-power format. The separation of inner reasoning from output lets the model be messy internally and disciplined externally. This is Vygotsky's inner/outer speech distinction made literal. Next steps: combine think/speak with power words inside the think section. Also: test whether the model uses the think section differently than it would use the same tokens without the markers (is the separation doing work, or is it just more tokens?).
The deliverable: An interactive CLI where you paste a simple Python snippet and the model traces through execution step by step, predicting the output.
Format:
> x = 5
> y = x + 3
> z = y * 2
> print(z)
<think>
x is 5
y is x + 3 which is 5 + 3 which is 8
z is y * 2 which is 8 * 2 which is 16
</think>
Output: 16
Why this is the right choice:
- Data generation is free and unlimited — programmatically generate code + traces
- Reasoning is visible and verifiable — run the code, check the answer
- Interactive —
python play.py, paste code, watch it think - Connects to our CoT research — code tracing IS chain-of-thought reasoning
- Existing benchmark: CRUXEval for comparison
- Hacker News hook: people will try their own snippets
- "5M parameter Python interpreter that shows its work" is a headline
Data pipeline:
- Programmatically generate simple Python snippets (assignments, arithmetic, conditionals, basic loops, string ops)
- Execute them to get ground truth output
- Generate execution traces (step-by-step variable state)
- Train with think/speak format from our experiments
- Scale to Chinchilla-optimal (~100-200M tokens for 5-10M params)
Code scope (what the model handles):
- Variable assignment: x = 5
- Arithmetic: y = x + 3, z = y * 2
- Conditionals: if x > 3: y = 1 else: y = 0
- Simple loops: for i in range(3): x = x + i
- String operations: s = "hello" + " " + "world"
- List operations: a = [1, 2, 3]; b = a[1]
- Print statements: print(x)
- NOT: imports, functions, classes, file I/O, exceptions
Model: 10M params (final), curriculum trained (power traces → think/speak)
Benchmark: CRUXEval (code reasoning, predict input/output)
Packaging:
git clone && uv sync && python play.py- CPU inference, no GPU needed
- README tells the full research story
--traceflag shows raw CoT, default shows clean output
Instead of asking "do power words steer attention?", ask "does the model verify its chain by re-attending to premises?" Compare attention patterns on correct vs incorrect examples. If the model attends more to premises on correct examples, that's a form of self-verification even without power words.