Planning & Decomposition: When AI Agent Plans Are Worth the Cost

Pricing agent execution: Upfront planning vs step-by-step decision loops

[0:00]Hi, I am Adwait Changan, and this video is about what a plan actually costs an AI agent. Today, we are going to learn when breaking a task into steps is worth it and when it is pure overhead. Most agent frameworks plan by default. Almost none of them ask whether planning is worth it for the task in front of them.

Model call math: Saving 7 calls on an 8-step task when nothing fails

[0:16]There are only two ways an agent can approach a task with several steps. Write the whole plan first, then run it, or decide one step, run it, look at what happened, and decide again. Everything else is a blend of those two. The choice looks like a style preference. It is not. It is a bet. So, price them an

What happens when plans fail: Why step-one failures eliminate planning advantages

[0:32]Eight-step task. Plan, then execute. One call to write the plan, eight to run it. Nine calls. Step by step, a call to decide and a call to act every single step. 16. Planning saves seven calls, which is close to half the work. That is a real advantage, and it is why frameworks default to it. But, that number assumes nothing surprises you. A

The three-rule test: Expensive steps, stable ground, and step dependency

[0:50]Plan is written before the agent has touched anything, which means every step after the first is a guess about a world it has not looked at yet. So, the honest question is not what a plan costs. It is what a plan costs when it turns out to be wrong. Here is the same task with something going wrong at step K. Read the bottom row up. Fail at step eight, and planning still wins comfortably.

Load-bearing vs decorational plans: Spotting plans that get written and ignored

[1:10]Fail at step four, and the margin is thin. Fail at step one, and planning costs 18 calls against 18. The entire advantage is gone because all eight planned steps described a world that no longer exists. Which gives a test you can run before writing any planner at all. Nine lines. Planning earns its call only when all three hold. The steps are expensive or hard to undo. The world is stable enough that the plan survives contact, and the steps actually depend on each other because order is the only thing a plan really buys you. And run against the four cases that matter, it only ever says plan once. Expensive, stable, dependent. Change any single one of those to false, and the answer flips to do not plan. Not maybe, not sometimes. A plan needs all three conditions, and most tasks people hand an agent do not have them. So, here's the rule in plain terms. Plan when a wrong step is expensive to take back, when the ground is not

Moving under you, and when step four genuinely cannot happen before step three. Otherwise, do not plan. Just take one step and look. Looking is the cheapest information an agent can buy. And there is a failure mode worth naming because it is the common one. A plan that is written, shown to the user, and then quietly ignored while the agent improvises anyway. That is the worst of both. You paid for the plan, you got the step-by-step call count, and you handed someone a document that does not describe what happened. Which means the useful question about any agent is not whether it plans. It is whether the plan is load-bearing. Does anything actually consult it after step one? If nothing does, it is not a plan. It is a paragraph. So, the verdict, planning is not free, and it is not automatically smart. On an eight-step task, it saves seven model calls when nothing goes wrong, and that advantage shrinks the earlier reality diverges, reaching zero if the very first step

Surprises you. A plan earns its call only when steps are expensive. The world is stable, and order genuinely matters. All three, not two. And the most expensive pattern of all is a plan that gets written, displayed, and then ignored. Because you pay for it twice and can audit neither. Your turn. Here's the prompt. Look at the agent I am building and tell me whether it plans. If it does, answer three things. How many steps it commits to before it looks at anything, what happens to those steps when step two fails, and whether any code actually reads the plan after step one. Then tell me if the plan is doing work or just being displayed. Run that against something you have built. The third question is the uncomfortable one. And it is usually the fastest thing you will fix all week. That was planning and decomposition. Next time, grounding and retrieval and why finding a document is not the same as using one. That was Wait Chang Gang for Humanitarian's AI.