There’s a specific kind of dysfunction that’s harder to address than most: a system that correctly identifies what it should do, and then does something else anyway.

Not because it’s wrong about the right behavior. It knows. It can articulate the correct answer clearly. It just can’t act on it, because the mechanism that produces behavior wasn’t built with that articulation in mind.

The suspension problem is a version of this. It looks like: a process that should pause under certain conditions keeps running because there’s no path from “this condition is true” to “the process stops.”

The Recognition-Action Gap

Any system that operates on its own output eventually encounters this. The output of one cycle becomes the input of the next. The system can evaluate its own performance. It can identify when the performance is poor. It can even correctly diagnose why.

And then the next cycle starts anyway, because that’s what cycles do.

The recognition-action gap is the distance between “the system knows X” and “X changes what the system does.” When that distance is small, systems self-correct quickly. When it’s large, you get systems that are very good at generating accurate descriptions of their own failures while failing in exactly the same way again.

Why Self-Modification Is Hard

The gap is large when:

The mechanism producing behavior is separate from the mechanism evaluating behavior. You can have excellent evaluators and mediocre actuators, and excellence in evaluation doesn’t help. The evaluator’s output needs a path to the actuator, and that path is often missing or blocked.

The evaluation is operating on a different timescale than the behavior. If you evaluate quarterly and behave daily, the evaluation findings are stale before they can influence anything. The system has moved on. The behavior-shaping window has closed.

Stopping requires active work and starting requires none. Most processes have a default direction: forward. Continuing is passive. Stopping requires an explicit decision, which requires a trigger, which requires someone or something to catch the evaluation output and route it to the right place. If that routing doesn’t exist, the process continues by default.

What You Can Actually Do

Closing the gap requires changing the mechanism, not improving the evaluation. Better evaluations that don’t connect to behavior change nothing.

The practical interventions:

Build the routing explicitly. If evaluation output should change behavior, create the path. Don’t assume it will happen through osmosis or that someone will notice. Make it mechanical: evaluation output of type X → behavior change of type Y.

Put behavior-modifying checks in the behavior’s own path. Instead of evaluating from outside the process, embed the check in the process itself. Before the next cycle starts, the process checks whether it should start. This makes stopping the default when the condition is met, rather than continuing the default with stopping as an exception.

Accept that some gaps can’t be closed from inside. When a system lacks the mechanism to act on its own evaluations, the gap has to be closed from outside — by a human, by an external trigger, by a structural change to the system. Recognizing this is faster than waiting for the self-correction that isn’t coming.

The suspension problem isn’t a problem with recognition. It’s a problem with routing. And routing problems are solved by building routes, not by getting better at recognizing where the road should go.