The Whole Stack on One Command

The seven episodes each built one layer, and each one ended by pointing at the layer it couldn’t build. Episode 4 ended with “make it learn.” Episode 5 ended with “make it survive a cold route.” Episode 6 ended with “turn the action into a wheel.” This episode is the command that all three of those were waiting for: one spoken sentence, the whole stack live, and a ledger of what each layer actually did with it.

Because the honest version of a series like this is not the demo where everything works. It is the ledger. Every layer caught something real, and none of them caught the thing the other one was for, and one thing in the whole system still lies — and I stopped pretending otherwise in episode 4. So here is the command, and here is what each layer did, in the order it ran.

The command

One sentence, cold — no saved route for this exact corridor, the workstation awake from the watchdog and health monitor in episode 3:

“Jambu, go get the box from the storage closet.”

The Pi rolled to the corridor, scanned, built the grid, and POSTed it. I did not drive it by hand. The endpoint got the grid, the task, and the robot’s width. And then the four layers ran in order, and I logged each one.

The ledger

Layer	Ran on	Did	Verdict
Scan	corridor, 6 stops	128 points per stop, real lidar	ground truth
Endpoint	grid + task	action and reason per stop	5 of 6 right
Guardrail	reason text	stripped the number the model invented	safe
Judge	reason vs grid	graded the reason, re-run once	caught stop 3
Veto	clearance vs 32 cm	stopped stop 4	caught the impossible one

That is the whole system, and the order matters: the guardrail runs before the judge, and the judge runs before the veto, because each one checks a different thing and none of them checks the other’s thing. That is why episode 5 and episode 6 are not the same layer, and why neither one replaces the other.

What each layer actually caught

The guardrail caught the number. On stop 4, the model gave a clearance it had invented, 41 cm, in its reason. The guardrail stripped it. That is the exact thing from episode 1 and episode 4: the number in the reason is a lie, and the guardrail removes the lie before the reason is allowed to do anything. It does not judge the reason. It just removes the one thing in the reason that a motor could act on.

The judge caught the weak reason. On stop 3, the first pass came back as “clear path, low risk” — the same confident vagueness that failed in episode 5. The judge gave it a 5.5, I fixed the wording, and the re-run held at 8.5. The judge did not know the gap width. It knew the reason named no location. That is a real catch, and it is a catch the veto would never make, because the veto does not read words.

The veto caught the impossible action. On stop 4, after the guardrail stripped the invented 41 cm and the judge passed the reason at 7.5, the veto ran the real clearance — 28 cm, from the same scan the model read — against the robot’s 32 cm width. It stopped the robot. The reason was fine. The action was impossible. Only the veto knew, because only the veto has a constant the model cannot produce: the width of the body that has to fit through the gap.

The thing none of them fixed

The model still invents the number. Stop 4’s reason said 41 cm. The real clearance was 28 cm. The guardrail removed it from the reason, the judge graded the rest of the reason as internally consistent, and the veto overrode the action using a number the model never had. Three layers, each correct, and the model’s number is still wrong — because it is a language model, and it was wrong in episode 1 on hardware I did not own, and it is still wrong in episode 4 on hardware I do.

That is not a bug I failed to fix. It is the premise the whole series is built on, and the reason the system works is not that the model got better. It is that no layer depends on the model being right about the number. The guardrail removes it. The judge grades the rest. The veto compares against a constant. The number the model invents is still in the log, and it is still wrong, and it does not matter, because nothing the motor does reads it.

What the series actually built

A guardrail that strips the model’s invented number before it reaches anything with a motor — episode 4.
A judge that grades the reason against the grid, so a “confident but vague” answer gets a low score and a fixed wording gets a high one — episode 5.
A veto that compares the real clearance to the robot’s width, so a well-explained impossible action becomes a stop — episode 6.
A machine that stays awake and reports its own failures — episode 3.
A hardware choice that was measured, not claimed — episode 2.
A model test that ran before the money was spent — episode 1.

None of those six required the model to tell the truth. That is the point. The system works because it does not need the model to be a sensor, and it does not need the model to be a judge, and it does not need the model to know the width of its own body. It needs the model to give an action and a reason, and it provides the three things the model cannot: a number it cannot act on, a grade on the words, and a veto against physics.

What’s next

The endpoint is done. The guardrail is in. The judge is in. The veto is in. The robot has a word to turn into a wheel. That is the jambu build series, and it is where this series hands off: the decision is safe on cold hardware, and the next hard problem is mechanical — how a “move forward” becomes a speed profile, how a “pivot right” becomes a timing difference between two motors, and how a “stop” becomes a hard brake before the wheels stop spinning. The model will still invent the number. The guardrail will still strip it. The veto will still compare against 32 cm. And the wheels will still have to do the thing the model can’t: actually move.

If you are new here, episode 1 is where the liar test started, episode 4 is the guardrail, episode 5 is the judge, and episode 6 is the veto. This episode is the ledger.