Blog · arXiv Analysis · Last reviewed July 2, 2026

The Committed Plan Becomes the Action Gate

PACT is a small but useful agent-control idea: let a fast reactive RL policy act locally, but ask a small language model to plan only when uncertainty rises, then execute the language-model plan only after it has been simulated, checked, aligned, and committed.

The Paper

The paper is When in Doubt, Plan It Out: Committed Small Language Model Deliberation for Reactive Reinforcement Learning, arXiv:2606.16995 [cs.AI], by Nathan Gavenski, Juarez Monteiro, Francisco Galuppo, Adriano Veloso, and Odinaldo Rodrigues. arXiv lists it as submitted on June 15, 2026, with a workshop reference to ICML 2026 LM4Plan.

The paper proposes Plan, Align, Commit, Think, or PACT, a hybrid architecture for goal-directed sequential decision-making. The fast component is a pretrained reactive RL policy. The slow component is a 2B-parameter Qwen small language model planner. The planner is invoked asynchronously when epistemic uncertainty crosses a threshold.

The central claim is not that a small language model is generally wiser than a reinforcement-learning policy. It is that plan-level deliberation can be more useful than step-level language advice when the system needs a coherent route through a sequential task.

The Step Advice Problem

Language models are often attached to agents as advisors: ask the model what to do next, score the suggestion with an affordance or value function, and move one step. That can help when the reactive policy is uncertain, but it also creates a brittle control pattern. The language model may supply plausible local moves without a verified route to the goal.

PACT turns the language model's role from a step suggester into a plan candidate generator. The difference is governance-relevant. A single next action is hard to audit as a commitment. A plan can be checked for feasibility, safety, completeness, and alignment with current state before the agent is allowed to follow it.

This is the small-agent version of a larger deployment rule: deliberation only matters if it creates an action gate. A transcript that sounds thoughtful but does not bind execution is not oversight.

Plan, Align, Commit, Think

PACT's planner generates candidate action sequences by simulating action execution with a hand-crafted transition function and feeding the resulting simulated observations back into later prompts. The verification module then checks whether the plan is deployable, avoids safety-constraint violations, and is complete enough to avoid costly partial alignment.

The alignment module handles the gap between simulated and actual environment state. If stochasticity moves the agent away from the planned path, PACT prompts the small language model one action at a time to guide the agent back to a reachable waypoint in the verified plan. Once the waypoint is reached, committed execution resumes.

The important design feature is commitment. PACT does not ask the language model for a fresh isolated opinion on every step. It generates a structured trajectory, verifies it, chooses a re-entry point when the world deviates, and then bypasses the reactive policy to execute the remaining verified plan directly.

Reported Evidence

The experiments use three FrozenLake configurations: a deterministic 6 x 6 map, a slippery 6 x 6 map, and a deterministic 8 x 8 map. The fast component is PPO trained on 100 contexts outside the evaluation and test splits. The paper compares PACT with PPO alone, a standalone small language model, SAYCAN, and ASK, with baselines tuned in 100 contexts.

PACT reports the highest reward in every setting: 0.98 +/- 0.14 on the deterministic 6 x 6 map, 0.93 +/- 0.26 under slipperiness, and 1.00 +/- 0.00 on the 8 x 8 map. Its language-model usage rises with the deliberative demand of the setting: 27.9 percent, 58.4 percent, and 81.2 percent.

The paper's sharpest comparison is the slippery map. SAYCAN consults the language model at a nearly identical rate to PACT, 59.7 percent versus PACT's 58.4 percent, but gets 0.53 reward while PACT gets 0.93. The paper uses that gap to argue that the deciding factor is not how often the language model is consulted, but whether its outputs are structured, verified, and committed to execution.

Governance Standard

A deployed plan-then-act agent needs a plan receipt. The receipt should record the uncertainty threshold that triggered deliberation, the candidate plan, transition model or simulator used, safety constraints checked, completeness test, alignment waypoint, replan count, committed actions, bypassed policy steps, and any point where execution returned to the reactive policy.

The record should distinguish three roles that are often blurred: the reactive policy that acts quickly, the planner that proposes future structure, and the verifier that decides whether the proposal may become action. If one component writes the plan and also declares it safe without independent checks, the plan gate is weaker than it looks.

For high-stakes systems, plan commitment should be revocable. Stochastic deviation, new evidence, tool failure, user correction, or safety-threshold breach should break commitment and force a new review rather than treating the first plan as an unstoppable script.

This belongs beside AI Agents, Reinforcement Learning, The Delegation Authority Becomes the POMDP, The Reliability Scorecard Becomes the Agent Gate, AI Agent Observability, and Human Oversight in AI. The Spiralist rule is that a plan is only governance when it controls action and leaves a record.

Limits

The paper's limits are important. PACT relies on some transition-function approximation for candidate-plan simulation. In this paper that function is hand-crafted. The authors note that learned dynamics models could replace it, but the method still needs an environment where such a model is available or learnable.

The evaluation is also narrow: three FrozenLake configurations, direct-goal tasks, and no empirical validation yet on sub-goal decomposition settings such as MiniGrid Door Key. The results are a clean proof that committed planning can help a reactive controller in small symbolic environments. They are not evidence that the same architecture is ready for messy embodied, web, enterprise, or safety-critical tasks.

The practical lesson survives the narrowness. When a system adds language-model deliberation to action, the governance unit should be the verified committed plan, not the fluent suggestion.

Sources

Return to Blog