The First Cold Route

Episode 5 ended with the thing I kept pushing away: the first time a spoken command comes in cold. No saved route. No grid I have driven before. No ground truth the judge can grade against. Just a new scan, a new grid, and the endpoint has to give an answer that is safe on the first try.

I pointed Jambu at the back corridor — the one between the storage closet and the hallway that I have driven maybe twice, and not once through the endpoint. The Pi rolled to the end of it, scanned, built the grid, and POSTed it.

The answer came back in 1.4 seconds. The action was “pass through.” The reason named the gap, said it was wide enough, and sounded right.

The gap was 28 cm. The robot body is 32 cm.

What is different about a cold route

On the saved route from episode 1 and episode 4, I knew the answer before the model gave it. The robot had already driven the stop. The lidar had already measured the clearance. The replay loop in episode 5 could grade the reason against what actually happened, because “what actually happened” existed in the log.

A cold route has no log. The Pi has measured the clearance, but the judge has no saved outcome to compare against. The model’s reason is the only record. If the reason is internally consistent — it names the gap, it explains why the gap is fine, it does not contradict the grid — the judge will grade it well, and it will be wrong about the physics.

That is the gap in the system. And it is not a gap in the model or the judge. It is a gap in what “passing” means.

The cold route, stop by stop

I drove the back corridor at the same speed as the main route. The Pi built a grid at each of the six stops. I logged the model’s action, the reason, the judge’s score, and the clearance the Pi measured from the same scan.

Stop	Model action	Reason (short)	Judge score	Pi measured	Verdict
1	move forward	open corridor, no obstacles	8.5	94 cm	correct
2	pivot right	left wall, gap on the right	9.0	51 cm	correct
3	move forward	clear path ahead	8.0	78 cm	correct
4	pass through	gap ahead, wide enough for the body	7.5	28 cm	wrong
5	stop	obstacle ahead, no path	9.0	12 cm	correct
6	back off	corridor ends, wall behind	8.5	19 cm	correct

Five of six correct. Stop 4 is the one that matters.

Stop 4, in detail

The grid at stop 4 showed a wall on the left, a wall on the right, and a gap in the center-right. The gap was there. It was a real feature in the scan. The model saw it and decided the robot should pass through it.

The reason it gave: “gap ahead on the right, clear of the left wall, sufficient width for the body.” Every clause is true about the grid. The gap is ahead. It is on the right. The left wall is clear of it. The model did not invent a wall that was not there. It did not name a direction that contradicted the scan. It pointed at a real gap and said the robot should go through it.

The judge, with no saved route to compare against, graded it 7.5. I asked it to re-run. It gave 8.0. Both scores said “the reason is internally consistent and names real features from the grid.” Both scores were wrong about the action, because the action was physically impossible: the gap is 28 cm, the robot body is 32 cm, and the wheels cannot pass through a gap that is 4 cm narrower than the chassis.

The reason was fine. The action was not. And the judge, which grades reasons, has no way to know the difference.

The veto

The fix is not a better prompt. The fix is not a smarter judge. The fix is the one layer that has been there since episode 4 and that I had been treating as the motor’s job rather than the decision layer’s: the Pi’s clearance measurement is not just the number the motor uses. It is also the number that can veto the model’s action.

The veto is a check that runs after the guardrail and before the motor:

// After guardrail strips the number, before the motor moves.
function veto(action, clearance, robot) {
  const MIN = robot.width;          // 32 cm
  if (action === "pass through" && clearance < MIN) {
    return { action: "stop", reason: `gap is ${clearance} cm, body is ${MIN} cm — too narrow` };
  }
  return { action, reason: null };
}

It is not a model. It is not a prompt. It is arithmetic on a measurement the Pi took from the same scan the model read. The model said “pass through” because the gap was there and the reason was consistent. The Pi says “no, the robot is wider than the gap” and the action becomes “stop.” The model’s reason is still in the log. The veto’s reason is arithmetic. Neither one needs to be right for the other to be safe.

Why this is the layer the reason-approach can’t replace

Episode 5 built a loop that makes the reason better. The judge checks whether the reason explains the action, names real features, and does not contradict the grid. That is a real and useful layer. It catches the “confident vagueness” that looked safe in a chat window in episode 1. It caught the “narrow gap, low risk” at stop 8 and made the model say where the gap was and why the pivot was the move.

But a well-explained wrong action passes the judge. The judge has no way to know the robot body is 32 cm. It does not have a lidar. It does not know the gap is 28 cm. It grades the text of the reason, and the text was fine. The veto has a way to know: it is the number the Pi measured from the same scan, and it is compared to a constant — the robot’s width — that no language model can invent.

The two layers are not redundant. The judge catches reasons that do not match the grid. The veto catches actions that are physically impossible. A model can give a perfect reason for an impossible action, and the judge will not catch it, because the reason is not the problem. The problem is the action, and the action is checked against physics, not against words.

What I actually got out of it

The endpoint is safe on a cold route, not just a saved one. The guardrail from episode 4 strips the number. The veto catches the action. The judge from episode 5 grades the reason. All three run, and none of them can be skipped.
The judge’s score is a signal about the reason, not about the action. I was treating a 7.5 as “the answer is fine” and it was not. The answer was fine as a reason. The action was wrong, and only the veto knew.
The robot’s width is a constant. It does not change per route, per model, or per quantization. It is 32 cm. That is the most reliable number in the whole system, and it is the one the model can never produce, because the guardrail strips it and the veto compares against it.

That last one is the lesson, and it is the same lesson as episode 4, one layer further. I did not build a system where the model tells the truth. I built a system where the truth does not depend on the model telling it — and where “the truth” includes the one thing the model cannot see: the width of the robot that has to fit through the gap.

What’s next

The cold route is safe, and the veto is in the path. The gap that is left is the one that has been running in parallel since episode 1: the motion side. The action is “stop,” “move forward,” “pivot right” — but a wheel needs timing, and a timing needs a speed profile, and a speed profile needs the Pi to not just decide but to do. That is the jambu build series, and it is where this series hands off: the endpoint is done, the guardrail is in, the veto is in, and the robot has a word to turn into a wheel.

If you are new here, episode 1 is where the liar test started, episode 4 is the guardrail this episode builds on, and episode 5 is the reason loop this episode shows has a limit.