Your Agent Does Not Need a Longer Plan. It Needs a Catching Feature.

A long-horizon agent can take many locally reasonable steps after the premise behind them has stopped being true. Each action remains coherent. The trajectory does not.

Adding detail to the plan rarely fixes this failure. The new detail is derived from the same internal map that is already diverging from the environment. The system needs an observation that the plan did not manufacture.

In orienteering, a catching feature is a recognizable feature beyond the target: reaching it confirms an overshoot. I adapt the term for agent control to mean an external signal that makes a missed boundary, wrong branch, or overshoot loud. Unlike the original navigation term, that signal need not sit physically beyond a target.

A Plan Is Not a Position Fix

Plans are valuable because they turn an outcome into a sequence. They are dangerous when the sequence becomes evidence for itself.

An agent reads a repository, infers the architecture, chooses a repair, and begins editing. A hidden generated file invalidates the inferred ownership boundary. The agent can still produce sensible patches, tests, and explanations. Fluency masks the fact that every later action is now dead reckoning from a bad fix.

Longer tasks increase the room for this kind of accumulated divergence, but duration is an imperfect proxy. METR's task-completion time horizon is explicitly a measure of task difficulty at a target success probability, not the amount of time an agent can operate autonomously. METR's limitations note also cautions that the evaluated software tasks do not represent all real-world work.

The architectural implication is simple. Do not ask only whether the plan is complete. Ask what the environment should reveal if the plan remains correct.

A plan predicts a path. A recovery architecture names the observation that would prove the path wrong.

Advance in Bounded Legs

The International Maritime Organization's voyage-planning guidance separates appraisal, planning, execution, and monitoring. Monitoring is not a ceremonial progress report. It checks the vessel's progress against the plan so that deviation becomes actionable.

I translate that into an agent leg with four fields:

1. Action: the bounded work to perform now.
2. Expected observable: the state that should become visible if the model is right.
3. Catching feature: the signal that proves a wrong branch, missed boundary, or overshoot.
4. Exit: the safe state to preserve if neither signal appears.

For a schema migration, the expected observable might be a new column plus a passing compatibility test, while the catching feature is a consumer still reading the retired field. For research, two independent primary sources might support the mechanism; a source showing that the key term means something different in the target domain would expose divergence.

The leg should be short enough that a mismatch remains cheap to repair. "Implement the feature" is usually too large. "Change the parser while preserving the current output fixture" creates a nearer observation and a safer exit.

Design the Catching Feature

A checkpoint says where the agent hopes to be. In this agent-control adaptation, a catching feature says what reality will look like after the system has crossed a boundary it should not have crossed.

Good catching features have three properties: they are external to the reasoning chain being tested, difficult to explain away with fluent prose, and early enough that stopping still matters.

Tests can serve this role, but only when they touch the disputed boundary. A unit test written from the same mistaken assumption may strengthen the illusion. Better signals often come from a consumer contract, an independent data source, a rendered surface, a live read-only check, or a fixture preserved before the change.

This is the same reason a cheap reality probe can be more valuable than another reviewer. Several agents discussing the same trace may diversify language without diversifying evidence.

Give the Agent a Lost Procedure

Detection without recovery produces a sophisticated alarm. The workflow also needs a deterministic response.

State	Required Action	Evidence to Leave the State
On track	Continue the current bounded leg.	The expected observable appears and no catching feature fires.
Divergence detected	Preserve the trace and stop extending the plan.	The conflicting observation is recorded without reinterpretation.
Lost	Re-establish the current position from evidence independent of the failed reasoning chain.	Evidence independent of the failed reasoning chain establishes the current state sufficiently for the next bounded leg.
Featureless	Shorten the next leg, survey, diversify evidence, or preserve options.	A new observation reduces the uncertainty that blocked the route.
Consequential boundary	Return to the legitimate decision owner.	The owner approves the commitment with the accumulated evidence.

The FAA's pilot guidance treats being lost as a condition with a procedure, not a reason to fly the planned heading more confidently. Its aviation-specific actions do not transfer literally to software agents. The deeper pattern does: maintain control, seek recognizable external references, communicate the condition, and use independent assistance.

More specialized FAA navigation guidance makes the boundary even clearer. When required navigation performance degrades or is lost, operators need procedures for terminating that navigation mode and transferring to another method. Recovery begins by admitting that the current method no longer has authority.

A lost agent should not be allowed to reason its way back to confidence using only the trace that made it lost.

Featureless Terrain Requires Shorter Commitments

Some work offers excellent feedback. A compiler, contract test, or database constraint can make a wrong step loud. Strategy, open-ended research, and novel architecture often provide weaker signals.

Do not invent precise checkpoints that the environment cannot support. Shorten the leg. Run a probe and compare genuinely different sources or implementations, while preserving a branch that can still be abandoned. Escalate when the next action would consume the exit.

I treat uncertainty as a reason to reduce commitment length, not as a reason to increase narrative detail. The less observable the terrain, the less path the system should accumulate before another fix.

What This Changes in Agent Architecture

A catching feature is not a new orchestration framework. It is a contract between a step and the environment.

The contract belongs beside the work state: expected observable, divergence signal, preserved trace, retry or independent position-check method, and exit condition. Probabilistic state machines provide the transition discipline. Durable execution preserves the state across interruption. Executable memory keeps the observation, owner, and review condition available when the work resumes.

The new requirement is epistemic: the recovery evidence must be less correlated with the failed path than another continuation of the same reasoning. Otherwise the agent is not re-establishing position. It is rewriting the map.

Use the Metaphor, Keep the Boundary

Software repositories are not seas, and organizations are not aircraft. Navigation doctrine does not prove that catching features improve agent success rates. It contributes a tested control shape: plan, monitor, detect deviation, preserve control, re-establish position independently, and switch methods when the current one loses authority.

That shape is useful because it changes implementation. A long-horizon agent should not receive only a goal and a longer plan. It should receive bounded legs, expected observables, a signal that makes the wrong route loud, and a lost procedure that can stop competent-looking motion.

The plan tells the agent where to go. The catching feature tells it when reality has stopped agreeing.

Related Reading

• The Probabilistic State Machine — explicit transitions, validators, and failure states.
• Durable Execution — preserving progress and side-effect safety across interruption.
• The Supervisor Pattern — when work reaches a consequence boundary.