# AI Behavioral Runtime > Steering a model's reasoning along principles defined in advance. It lifts the benchmark, and every step pays for it. - Site: isnan lab (https://lab.falah-isnan.com/experiments/ai-behavioral-runtime) - Author: Falah Isnan (https://falah-isnan.com/) - Published: 2026-09-23 - Updated: 2026-09-23 - Stack: Reasoning runtime / Gemini 3.1 Pro - Access: Research note - Interim result: Steering works. Forcing a model to reason along defined principles lifted the benchmark without touching native reasoning, which is the result the experiment was after. It is not free: the steering is paid on every step, and anything the principles never described is exactly as unsolved as it was before. ## The question Can a defined set of principles aim a model's reasoning in a better direction, without touching the reasoning itself? A Flash-class model, or any model that is not frontier, can hold plenty of knowledge and still fail because it aimed the reasoning the wrong way. Knowing the material and choosing what to do with it are not the same capability. This is not only a small-model problem. Gemini 3.1 Pro is one observed example: the capability of a large model, and still a run that ends at the wrong answer because it started down the wrong path. ## How it ran 1. **Watch where the run goes wrong.** Not which facts were missing — which turn the reasoning took. The failures that mattered were direction failures: a plausible first move that nothing later could recover from. 2. **Write the principles down.** The direction the run should take, stated as explicit principles rather than a longer prompt. The runtime holds them and forces the model to work along them. 3. **Leave the native reasoning alone.** Nothing replaces how the model reasons. The runtime only steers the process, so whatever the model is already good at stays available underneath. 4. **Run it again and count the cost.** The same problems, through the runtime. Read back both sides: where the result moved, and what the extra steering added to every step. ## The approaches ### The model on its own The model gets the problem and picks its own direction. Cheap, short, and entirely dependent on the first move happening to be the right one. - No steering overhead — you pay for the reasoning and nothing else. - Direction is whatever the model chose this time. - A wrong first move is rarely recovered later in the run. - Nothing about the failure tells you how to prevent the next one. ### The model inside the runtime The same model, made to work along principles that are defined in advance. The reasoning is still the model's own; the direction of it is not. - Direction is stated up front instead of rediscovered each run. - Native reasoning is untouched, so nothing capable is given up. - Every step carries the steering, and the steering is not free. - Outside the defined principles there is nothing holding the run. ## What came out Read against the same problems, on the same model. The benchmark moved; the figures behind it are not cleared for publication yet. - **Direction of reasoning** — Favours: The model inside the runtime (clear). Defined principles keep the run pointed at the problem it was given. This is the whole reason the runtime exists, and it is the part that worked. - **Benchmark result** — Favours: The model inside the runtime (clear). Good enough to lift that model's benchmark. The lift comes from fewer runs going the wrong way, not from the model knowing anything new. - **Cost per run** — Favours: The model on its own (clear). The steering has to be carried through the reasoning, so it is paid on every step. A native run is cheaper, and sometimes it is also correct. - **Cases outside the principles** — Favours: Not settled (narrow). Unsettled. A case the principles do not describe is not handled by either side — the runtime has nothing to steer with, and the native run is back to guessing. ## Trade-offs - Gain: Principles that are actually written down help the model work in a more correct direction, run after run. Cost: They have to be written down first, and a principle that is wrong is now wrong consistently rather than occasionally. - Gain: The benchmark for that model moves up without changing the model. Cost: Reasoning gets more expensive: the additional steering is carried through every step of the run, so the lift is bought with tokens. - Gain: Native reasoning is left intact, so the runtime rides on whatever the model already does well. Cost: It also inherits whatever the model does badly. The runtime aims the reasoning; it does not improve it. ## What is not solved 1. A case that falls outside the defined principles is still unsolved. The runtime has no fallback for it and does not detect that it has left its own coverage. 2. The lift was read on one model. Whether the same principles help across model families has not been tested. 3. The cost of steering was not separated per principle, so there is no evidence yet about which principles are earning their keep. 4. No benchmark figures are cleared for publication. ## Interim conclusion Steering works. Forcing a model to reason along defined principles lifted the benchmark without touching native reasoning, which is the result the experiment was after. It is not free: the steering is paid on every step, and anything the principles never described is exactly as unsolved as it was before. ## Process notes - The runtime directs the process only. Native reasoning is left exactly as it was. - The benchmark moved up, and the cost of reasoning moved up with it. - A case the principles never described is still unsolved, and the runtime does not notice it has left its coverage.