The Nudge Layer
Simulating the boundary of intent
The project reached a beautiful cadence when the question changed.
Not because the model changed. Not because the context window got bigger. Not because the system suddenly acquired some new native faculty of judgment.
The breakthrough was smaller than that.
The system learned to ask a better question before acting.
In the previous piece, I argued that the recursive limit is not model intelligence, but rather the source of intent. This piece is about the small control layer that appeared next: a way for the system to ask whether it had reached that limit, or merely reached the next architectural move implied by intent already supplied.
For a long stretch, the work kept reaching plateaus and misreading them. Sometimes it would stop too early, asking for new human intent when the intent had already been supplied. Other times it would keep moving too easily, chaining correct next steps until the chain itself became drift.
Both errors looked different on the surface.
One looked like humility. One looked like momentum.
But structurally they were the same kind of failure: the system had not correctly classified the boundary it had reached.
Was this a source-of-intent boundary? Was this a sequencing boundary? Was this an absorption boundary? Was this a synthesis boundary? Was this a critique boundary? Was this simply the next architecture attempt implied by premises already supplied?
The system was not failing because it lacked the words. It was failing because it did not know what kind of boundary it was standing at.
The nudge layer changed that.
The old failure mode
The old failure mode was not incompetence.
It was over-deference.
The system would surface a gap between current evidence and stated purpose, then quietly convert that gap into a question for the operator.
At first, this looked prudent. The machine was not overstepping. It was asking for external direction. It was preserving the source of intent.
But the posture was too blunt.
A gap between current evidence and stated purpose does not always mean the operator needs to reauthorize the purpose.
Sometimes the purpose is already clear.
Sometimes the gap is not:
What does the operator want?
but:
What architecture is required to make the stated purpose real?
That distinction matters.
If the source of intent has already been supplied, the machine should not ask the operator to supply it again. It should ask what architectural means are missing.
What carrier? What trace? What model attempt? What pressure test? What inheritance structure? What routing move?
The project had been asking for intent when it owed architecture.
That was the false stop.
The opposite failure mode
The opposite failure mode is false autonomy.
The system keeps moving because every next move looks locally correct.
A synthesis lands. A front door absorbs it. A structured model follows. A decision surface narrows. A test candidate appears. A routing update becomes obvious.
Each step is defensible. Each step is coherent. Each step follows from the previous one.
And yet, at some point, correct moves chained too quickly become their own drift vector.
The issue is not that any single move is wrong. The issue is that the system stops noticing when a closure has become a real pause point.
A real pause point does not always require the operator to decide a new purpose. It also does not always require a full fresh-context critique.
But it does require classification.
The system has to know whether the next move is:
local continuation
repo-local absorption
external synthesis
new operator intent
fresh-context critique
or no move yet
Without that classification, the system either stops too early or continues too smoothly.
Both are failures of boundary recognition.
The nudge
The new question is simple:
What additional external source of intent or direction is needed next to keep developing the project toward its higher-level purpose?
This is not the same as asking:
What next?
That question invites task generation.
The better question asks the system to classify the boundary before proposing action.
It can answer:
No new source intent is needed. The durable purpose is already supplied. The next move is a bounded architecture attempt.
Or:
No new source intent is needed. The correct next move is absorption and routing. The architecture has moved, and the front door is now stale.
Or:
The intent and means are clear. The unresolved question is sequencing. Several routes are valid, but they would pressure different parts of the architecture.
Or:
This is a real pause point. The next move should not auto-chain. The pause should route to external synthesis from current durable state.
Or:
The current context itself needs reset. Run fresh-context critique from repo and grounding note.
Or:
The operator really does need to supply a missing premise.
That is the power of the nudge. It does not merely ask the machine to continue. It asks the system to simulate the operator’s boundary question:
Is this an intent problem, or do we already have enough intent to keep working?
That small simulation changes the cadence.
Simulation as intelligence
This is where Max Bennett’s account of intelligence becomes useful.
In A Brief History of Intelligence, Bennett frames intelligence as a layered evolutionary accumulation. Steering. Reinforcement learning. Simulation. Mentalizing. Language.
The important thing is not the exact biological mapping. It is the structural pattern.
Intelligence did not arrive all at once.
New layers appeared. Each layer reorganized the ones beneath it. A later layer did not merely add capacity; it changed what the whole system could do.
Simulation is one of those breakthroughs.
A system that can simulate an action before taking it has crossed an important threshold. It no longer merely reacts. It can rehearse. It can model a possible next state. It can choose not to act yet.
The source-of-intent nudge is small compared to biological simulation. But structurally, it belongs to the same family.
Before the workflow acts, it simulates a boundary check.
Do I need new intent? Do I need sequencing? Do I need synthesis? Do I need critique? Do I need to preserve the plateau instead of chaining forward?
That is not magic. It is not autonomy. It is not the model becoming conscious of its own limits.
It is a control layer.
And control layers matter.
Intelligence as stack
This is why I keep returning to the idea that AGI is more likely to arrive as a stack than as one bigger model.
A single model can generate. A stack can constrain generation. A stack can preserve durable memory. A stack can separate roles. A stack can verify state. A stack can route decisions. A stack can ask whether the next action is authorized by existing intent.
The nudge layer is one small example.
The base model did not change. The behavior of the system changed because the architecture around the model changed.
There was now:
durable repo state
external grounding note
advisor surface
execution surface
source-of-intent guard
source-of-intent nudge
fresh-context critique cycle
approval gates
repo-local workflow rules
No single element is impressive in isolation.
Together, they produce a different kind of behavior.
The system becomes less likely to ask for new intent when the intent is already present. It becomes less likely to continue when the context needs exterior pressure. It becomes more likely to classify the boundary before acting.
That is not simply better prompting.
It is stacked cognition in miniature.
The source of intent remains external
The nudge does not replace the operator.
That is crucial.
The system is not generating the highest-level value function. It is not deciding what the project is for. It is not originating the source of intent.
It is simulating a narrower function:
Given the durable sources already supplied, is new external intent actually needed here?
That simulation can return “no.”
And when it returns “no,” the system can keep moving.
That matters because many AI workflows fail by routing everything ambiguous back to the human. The human becomes the universal exception handler. The system never learns to distinguish between missing intent and unresolved means.
But the opposite failure is just as dangerous. A system can also overrun its source of intent by treating every next artifact as self-authorizing.
The nudge protects against both.
False stop:
I need the operator to decide whether scale matters.
Correct classification:
Scale is already source intent. The unresolved question is what architecture makes scale legible.
False autonomy:
Another artifact follows naturally from the last one.
Correct classification:
This is a real pause point. The next move should route to absorption, synthesis, or critique before chaining forward.
The operator remains the source of intent. The system gets better at recognizing when that source has already spoken.
A better stopping condition
Most discussions of AI agency focus on action.
Can the system do more? Can it plan more steps? Can it use more tools? Can it persist longer? Can it operate with less supervision?
Those questions matter. But they are not enough.
A serious agentic system also needs stopping conditions.
It needs to know when to defer. When to route. When to synthesize. When to ask. When to preserve a plateau. When to return to durable truth. When not to ask because the premise is already supplied.
The last one is easy to miss.
Knowing when to ask for human intent is important. Knowing when not to ask is just as important.
A system that asks too often never becomes useful. A system that asks too rarely becomes unsafe or incoherent. A system that asks the wrong kind of question wastes the operator’s role.
The right behavior is not more autonomy or less autonomy.
The right behavior is better boundary classification.
The ladder
The method now has a clearer ladder.
First:
Do not promote unresolved means into unresolved intent.
That is the source-of-intent guard.
If the durable sources already state the end, the system should not ask the operator to restate the end. It should identify the architectural means required to make the end real.
Second:
Ask whether external intent is actually needed.
That is the source-of-intent nudge.
At local plateaus, after absorptions, or when the next move is unclear, the system simulates the boundary question. It classifies the next state: continue, absorb, route, synthesize, ask, or reset.
Third:
Reset when the durable context itself needs reconstruction.
That is the fresh-context critique cycle.
Fresh threads read only the repo and grounding note. They do not inherit the working thread’s momentum. They reconstruct the project from durable truth and surface what no longer coheres.
The ladder matters because each step has a different cost.
A nudge is light. A synthesis is heavier. A fresh-context critique is heavier still. A new operator premise is not a routine step. It is a real intervention into the source of intent.
Without the ladder, every plateau looks the same.
With the ladder, the system can ask:
What kind of plateau is this?
Not a bigger model
The interesting part is how little changed.
The model did not become smarter.
The stack changed.
A small prompt was inserted at the right layer. A method principle made the boundary explicit. The advisor role acquired a sharper job. The execution surface stopped treating every pause as either continuation or operator decision. The fresh-context critique cycle became a heavier escalation, not the default response to every local plateau.
That is the lesson.
A system can become more intelligent without the base model changing, because intelligence is not only generation. It is also organization, routing, memory, constraint, simulation, and stop conditions.
This is why the stack frame matters.
A raw model proposes. A governed stack classifies. A method decides which surface should act next.
The nudge layer is small. But it is exactly the kind of small layer that changes the whole behavior of the system.
The boundary before acting
The project reached a beautiful cadence when the question changed.
Not:
What should we do next?
But:
What kind of external intent, if any, is needed before the next move?
That question preserved the operator’s role without making the operator a bottleneck. It gave the machine enough room to continue when the source of intent was already present, and enough discipline to stop when the current context needed exterior pressure.
That is the shape I am interested in.
Not autonomous machines replacing human intention. Not humans manually steering every next step. Something stranger and more useful:
systems that can simulate the boundary of intent before they act.
The system did not become smarter because the model changed.
It became smarter because the stack learned to ask a better question before acting.
/// /// /// ASK
meta repo https://github.com/apexSolarKiss/control-surface
worked-example repo https://github.com/apexSolarKiss/asset-pipeline-ASK
prior workflow pieces: