The planner says one thing, the executor does another

The plan was right when it was written. Then the world moved, the observation never fed back, and the agent confidently executed a plan that no longer fit.

B

Balagei G Nagarajan

3 MIN READ


Two linked AI nodes, a planner and an executor, connected by a light filament that is fracturing as they point in diverging directions
2% of all agent failures across 1,642 traces.
— from “The planner says one thing, the executor does another”
 <p><b>Key facts.</b></p>
 <ul>
   <li>The planner-to-executor seam is exactly where information leaks: by the Data Processing Inequality, every inter-agent handoff can only lose information, never add it, and under matched token budgets a single agent matched or beat multi-agent setups in nearly every condition (<a href="https://arxiv.org/abs/2604.02460" target="_blank" rel="noopener">Tran & Kiela, arXiv:2604.02460</a>, 2026).</li>
   <li>That points the bulk of failures at coordination and design, not the model's raw capability, which is why a stronger model rarely fixes a plan that has drifted from the actions.</li>
 </ul>
 <h2>What is planner-executor desync?</h2>
 <p>Planner-executor desync is when the agent's planned step and its actual tool call point in different directions. The planner decides "update the staging record." The executor calls the production endpoint. Or the plan was correct when it was made and the world moved: a file got deleted, a ticket got closed, and nothing updated the plan. The agent acts on a stale map. This shows up in MAST as reasoning-action mismatch, 13.2% of all agent failures across 1,642 traces. The trace looks coherent. The action was wrong.</p>
 <h2>Why does the plan drift from reality?</h2>
 <p>The plan lives in the context window as text. Execution happens at a tool call boundary. Nothing enforces those two are the same thing. A model can narrate one intention and emit a different call. It happens when tool names are similar and the model picks the wrong one. When parameters are ambiguous and the model fills them from stale context. When the plan was made early and the model re-interprets it steps later. The trace says "update record 472." The tool call hits record 274. Nobody notices until a downstream query returns wrong data.</p>
 <div class="fig"><img src="/blog/article14-diagram.png" alt="A loop where an executor's observation fails to feed back into the planner, so a stale plan keeps driving actions that diverge from the current world state"/></div>
 <h2>How do you keep them in sync?</h2>
 <p>Validate preconditions before each execution step, not just at plan creation. Surface explicit plan-state mismatches rather than letting the agent proceed on stale assumptions. If a file the plan assumed exists has been deleted, the agent should detect that and re-plan rather than failing silently. Which steps in your workflow are most exposed to this drift, and where plans can safely be built ahead of time, is what VibeModel maps as the Pattern Intelligence Layer.</p>
 <p>The pattern is simple: a plan is a hypothesis, not a fact, and an executor that never checks its actions against the current plan will ship the wrong work fluently. Replan on every observation, reconcile the executor's action with the planner's intent before it fires, and share real state across the handoff. None of that is a bigger model. It is a coordination layer that keeps intent and action pointed the same way, which is what VibeModel builds as the Pattern Intelligence Layer.</p>
 <aside class="jaside v-warn"><span class="col"><svg class="hook" width="28.5" height="34.5" viewBox="0 0 57 69" fill="none" preserveAspectRatio="none" xmlns="http://www.w3.org/2000/svg"><path fill="var(--pageBg)" d="M54 0V0.716804C54 25.9434 35.0653 47.1517 10 50L0 57V0H54Z"/><path fill="var(--acc)" d="M56.9961 4.15364C57.0809 2.49896 55.8083 1.08879 54.1536 1.00394C52.499 0.919082 51.0888 2.19168 51.0039 3.84636L56.9961 4.15364ZM9.09704 51.7557L8.49716 48.8163L9.09704 51.7557ZM6 69V59.2227H0V69H6ZM9.69692 54.6951L14.3373 53.7481L13.1375 47.8693L8.49716 48.8163L9.69692 54.6951ZM14.3373 53.7481C38.202 48.8777 55.7486 28.4783 56.9961 4.15364L51.0039 3.84636C49.8967 25.4384 34.3213 43.5461 13.1375 47.8693L14.3373 53.7481ZM6 59.2227C6 57.0268 7.54537 55.1342 9.69692 54.6951L8.49716 48.8163C3.55195 49.8255 0 54.1756 0 59.2227H6Z"/></svg><span class="rail"></span></span><span class="glyph"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z"/><path d="M12 9v4"/><path d="M12 17h.01"/></svg></span><h4>Watch out</h4><p>It happens when tool names are similar and the model picks the wrong one.</p></aside>

Frequently asked questions

Is this just the agent hallucinating?
No. The reasoning can be sound and the plan correct; the failure is that the executed action does not match it, or the plan was never updated after the world changed. Failure taxonomies track reasoning-action mismatch as its own distinct mode for that reason.

Does a single-agent design avoid it?
It reduces the handoff version, but not the stale-plan version. A single agent that plans up front and never replans on new observations drifts the same way. The fix is the observation-to-replan loop, not the agent count.

What is the one change that helps most?
Replan on every meaningful observation and reconcile the executor's next action against the current plan before it fires. That single gate catches both the drifted plan and the action that does not match it.


Share this post

Join the discussion

Have a take, a war story, or a question? Sign in with GitHub to comment and react. Comments are powered by GitHub Discussions, ad-free and yours to moderate.

Continue Reading

Find where your agent breaks, before you build it

Faultmap maps where your agent will fail from the goal and your data, then hands you the first test suite it has to pass.