TL;DR
Planning commitment is the choice of how far ahead an agent plans while some of the facts are still unknown. There are two extremes. A conservative agent relies only on what it has already seen and moves step by step: learn something new, plan the next chunk. An aggressive agent fills in the gaps with assumptions, writes the whole plan to the goal right away, and replans only after something breaks.
The main finding: both strategies end up with nearly the same accuracy; the difference is cost. The aggressive agent stumbles noticeably more often along the way. It only saves money when it has good hints: reliable statistics ("this holds 86% of the time") or common sense the model picked up in training. Without hints it guesses blind, misses, and the savings in requests all but vanish. One more nasty surprise: the model treats the hints it is given almost as facts. The higher the stated percentage, the harder it leans on it. If the hint is wrong, you get errors at scale.
The method: pick the mode based on the cost of a mistake, plus a hybrid. No hints, or mistakes are expensive: go conservative. Hints are reliable and mistakes are easy to roll back: plan aggressively. Need a middle ground: start aggressive and switch to step-by-step mode after N failures.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
MODE A (conservative): rely ONLY on what has been observed
→ plan to the nearest subgoal → execute → new facts → next chunk
MODE B (aggressive): fill in missing facts with assumptions
→ plan all the way to the goal → execute → on failure, replan from the current state
HYBRID (fixed): start in mode B
→ after N failures, switch to mode A
CHOOSING A MODE:
no reliable hints OR mistake is expensive/irreversible → A
hints are reliable AND mistake is cheap/reversible → B
not sure → hybrid
All of this fits into a single system prompt or an agent instructions file.
Example
Task: You run Claude Code in someone else's repo for an online store. You need to fix a broken build. You only partly know the project structure, and mistakes are cheap: everything happens in a local branch and can be rolled back with one command. This is the sweet spot for aggressive mode with a safety net.
Prompt:
You are fixing a broken build in an unfamiliar repository. You can't see
the full project structure.
Known hints (verified by the team, reliable):
- Tests live in tests/, business logic in app/services/.
- Dependencies are pinned in requirements.txt.
Operating mode: HYBRID
1. Start AGGRESSIVE: fill in missing facts with reasonable assumptions
(based on the hints and typical projects) and immediately write a plan
all the way through: from running the build to green tests.
Mark every assumption as [ASSUMPTION].
2. If an action is rejected or a command fails, replan from the current
state; don't start over. Count these failures.
3. After 2 failures, switch to CONSERVATIVE mode: rely only on what you
have seen yourself (command output, file contents). Don't assume.
Plan only to the nearest subgoal (e.g., "open file X and take a
look"), execute it, and only then plan further.
Don't delete or push anything without my confirmation.
Result: The agent first produces a long plan with an [ASSUMPTION] tag on every guess. After two failures it explicitly announces the switch to step-by-step mode and starts working in small, verifiable steps: look, then do the next thing. In the end you get either a fixed build or a clear list of what the agent actually saw versus what it merely assumed.
Why It Works
The weakness. When facts are missing and the model still builds a long plan, it patches the gaps with guesses. One wrong guess early on wrecks the entire tail of the plan. If the agent checks everything step by step, it's reliable, but it makes lots of extra requests and burns time. There is no mode that is good everywhere.
The strength. LLMs have common sense from training: for example, where pots are usually kept and where doors tend to lead. When the model's guesses match reality, a long plan saves a lot of calls (around 40% in the paper). The model is also great at following explicit hints, almost too great: it treats them nearly as facts.
How the method uses this. It combines both properties. Good hints turn guesses into near-certainties, and then an aggressive plan pays off. With no hints or a high cost of error, step-by-step mode kicks in, where there are no guesses at all. The hybrid takes the cheap start and hedges with a failure threshold.
Control knobs:
- Failure threshold N (when to switch): lower N is safer, higher N is cheaper.
- The [ASSUMPTION] tag: drop it and you can't see where the agent was guessing.
- How hints are phrased: the model reads "86%" almost as "always." If a hint might be wrong, say so explicitly.
- Subgoal size in conservative mode: "one step" gives maximum control, "up to the next fork in the road" gives fewer requests.
Prompt Template
This is a reconstruction based on how the paper describes the modes. The authors' verbatim prompts are in the appendix, not in the main text.
You are an agent solving this task: {task}.
Some facts about the environment are unknown to you. They will only be revealed as you act.
Known facts:
{known_facts}
Hints about what you can't see (may be inaccurate):
{hints_or_"none"}
OPERATING MODE: {AGGRESSIVE | CONSERVATIVE | HYBRID}
AGGRESSIVE:
- Fill every missing fact with an assumed value (from the hints
or common sense) and write a complete plan to the goal.
- Mark every assumption as [ASSUMPTION].
- Replan only when an action is rejected. Replan from the current
state, not from scratch.
CONSERVATIVE:
- Use only facts from the task statement and your observations. Ignore hints.
- The goal is usually unreachable from known facts alone, so plan to the
nearest subgoal (e.g., "explore {unknown}").
- Execute the subgoal, gather new facts, and only then plan further.
HYBRID:
- Start in AGGRESSIVE mode.
- After {N} failed actions, switch to CONSERVATIVE mode and say so.
Format for each round:
1. What I know for sure
2. What I'm assuming (if the mode allows it)
3. Plan for this round
4. Action
{safety_constraints}
What to fill in: {task} is the agent's goal; {known_facts} is what you know for certain; {hints_or_"none"} is statistics or team experience (if there's nothing, write "none"); {N} is the failure threshold (2–3 is sensible); {safety_constraints} is something like "don't delete anything without confirmation."
🚀 Quick start: paste this into the chat:
Here's a hybrid planning-mode template for an agent. Adapt it to my
task: [your task]. Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask what you know for sure, what's unknown, how reliable your hints are, and how much a mistake costs (easy to roll back or not). That determines the mode and the threshold N. It will take the structure from the template and assemble a ready-to-use instruction.
Limitations
⚠️ Toy environments: Tested on finding a coin in a grid of rooms and on moving objects around a house in a text simulator. Transferring this to real agent work is your experiment, not a result of the paper.
⚠️ The hints were always correct: The authors only provided accurate statistics. They didn't test what happens with wrong hints. But they did show the model leans on hints almost as if they were facts, so the risk is real.
⚠️ Without hints, aggressiveness doesn't pay off: The savings in requests are small and the errors are far more numerous. If you have no reliable data, go step by step.
⚠️ The hybrid isn't always better: In some cases the hybrid formalizer made even more mistakes than both extreme modes. The reasons: the model lost track of the agent's current position in the description and repeated made-up connections from the hints.
⚠️ Part of the method requires code: The PDDL formalizer variant (the model writes a formal description of the task and an external solver computes the plan) is for engineers. In a chat, only the variant where the model plans by itself applies.
⚠️ The conservative mode got no hints: The authors compared the two extremes. The in-between option, "step by step, but with hints," was left for future work.
How They Tested It
The researchers used two text-based worlds. In the first, Coin Collector, the agent has to find a coin in a grid of nine rooms, and the connections between rooms are hidden. The model received either precise statistics ("in 86% of cases room 2 is east of room 1") or nothing. In the second, ALFWorld, the agent has to move an object around a house, and here only common sense helped the model. 100 tasks per domain.
They compared four combinations: a planner (writes actions itself) and a formalizer (writes PDDL, and an external solver computes the plan), each in aggressive and conservative variants. Known approaches served as baselines: ReAct for the conservative planner and Plan-and-Act for the aggressive one. The aggressive formalizer was the authors' own invention. They tested three models: Gemini-3-Flash, DeepSeek-Flash, and Qwen3.8-27B. They measured accuracy, number of failed attempts, API calls, and output tokens.
The result is surprisingly mundane: accuracy is nearly identical. Conservative methods produce far fewer failed attempts. Aggressive ones with hints save about 40% of calls. Without hints, the aggressive methods make lots of mistakes and save little: the guesses are mostly wrong.
The authors separately checked whether the conservative agent really invents nothing. It doesn't: almost no connections that didn't come from observations, while in aggressive plans missing data showed up in more than half of cases. Another unexpected result: the higher the percentage in a hint, the more readily the model believes it. The practical takeaway: choose the mode by two prices, the cost of a call and the cost of a mistake.
Adaptations and Extrapolations
These are my ideas; the authors didn't test them.
🔧 Technique: reliability labels on hints → less blind faith
Instead of "in 86% of cases tests live in tests/", write:
Hint (reliability: medium, verify at first opportunity): tests are usually in tests/.The idea is to break the "hint = fact" effect described in the paper. Whether it works is untested.
🔧 Technique: switch condition based on error type → a sharper hybrid
Instead of "after N failures," use "after the first irreversible error or two identical errors in a row, switch to step-by-step mode." This swaps a counter for a condition that fits your reality.
Extrapolation: put the cost of a mistake at the top of the agent's system prompt.
Before you start, estimate the cost of a mistake:
- The action is reversible (local branch, draft, test environment) → hybrid,
threshold of 3 failures.
- The action is irreversible (production, deletion, payment, customer email blast) →
CONSERVATIVE mode, only facts from observations, ask me for confirmation
before every step.
If you're not sure, ask me a question and don't act.
Resources
- Paper: Planning Commitment of LLM under Partial Observability
- Authors: Cassie Huang, Zhanwei Cao, Yeawon Lee, Nathalia Gomez, Zhuoyi Yang, Ian G. Harris, Tiffany Do, Jiayuan Mao, Li Zhang
- Universities: Drexel University, Northeastern University, University of California Irvine, University of Pennsylvania
- Approaches mentioned: ReAct (Yao et al., 2023), Plan-and-Act (Erdogan et al., 2025), PDDLego+ (Gong et al., 2026); Coin Collector and ALFWorld environments