Planning & Reasoning

Planning, in an agent, is mostly reasoning made explicit. Handed a goal, the model does what it was trained to do - produce text - but the text it produces is a decomposition: a breaking of the goal into an ordered set of sub-tasks, each small enough to attempt. 'Research mid-size civic library precedents and summarise what makes them work' becomes, in the agent's own reasoning, something like: decide what 'works' means here; find several strong examples; for each, gather the relevant facts; look across them for common features; check any specifics that matter; write the summary. This decomposition is not hard-coded - the model generates it, drawing on the enormous number of worked examples of planning and problem-solving in its training - and different runs may plan differently, which is both a strength (flexibility) and a source of variability (inconsistency).

A well-known and telling detail is that models generally reason *better when they reason out loud*. Prompted or trained to work through a problem step by step - to lay out its thinking before committing to an answer - a model tends to produce more accurate results than when it jumps straight to a conclusion, because the intermediate steps give it a scaffold to build on and catch some of its own slips. This is why so many agents 'think' visibly, narrating a plan and their reasoning as they go, and why modern 'reasoning' models spend deliberate effort working through a problem before answering. For you, this visible reasoning is a gift: it is the plan and the logic laid out for inspection, which is precisely what you need in order to judge whether the agent is on a sound track before it has spent forty steps proving it was not.

Crucially, the plan is not fixed once made. Because the agent runs in a loop, planning is iterative: the agent plans, takes a step, observes the result, and can revise the plan in light of what it learned - a promising line abandoned, a new sub-task added, an order changed. This is the source of an agent's real competence at open-ended work: it does not need a perfect plan up front because it can adapt as it goes, the way a person tackling an unfamiliar problem refines their approach mid-stream. It is also, as we will see, the source of a failure mode - the same adaptiveness that lets an agent recover from a dead end also lets it wander, or talk itself from a good plan into a worse one. Planning gives the loop direction; whether the direction is good is a separate question, and one you must not assume away.

Put planning inside the loop and you get the characteristic rhythm of agentic work: plan, act, observe, adjust, cycling until the goal is met. The agent forms a plan (or the next step of one), acts on it using a tool, observes what came back, and reasons about the result - did that work, what does it mean, what now? - then adjusts the plan and takes the next step. This is more powerful than one-shot problem-solving for exactly the reason iteration beats a single guess: the agent gets to *learn from contact with reality* at every turn. A search that returns nothing tells it the query was wrong; a calculation that gives an implausible figure tells it a step needs rethinking; a document that contradicts an assumption sends it back to revise. Each observation is a chance to correct, and a well-behaved agent uses them.

This loop is what underlies the genuinely useful things agents can do on multi-step design work: pursuing a research question through several rounds of searching and reading; debugging why an analysis gives an odd result; iterating a draft against a set of requirements; working through a checklist against a set of rules. In each, the value comes not from a single brilliant output but from the *cycle* - try, check, refine - run faster and more tirelessly than a person would, on the bounded, tool-using parts of the work. When it goes well, you hand over a goal and get back something that has already been through several rounds of self-correction, which is a real multiplier on the tedious middle of many design tasks.

But notice what the loop does and does not guarantee. It guarantees *iteration* - that the agent will keep trying, observing and adjusting. It does not guarantee *good judgement about the observations*, because that judgement is the same fallible reasoning at work. An agent can observe a result and draw the wrong lesson from it; can 'correct' a good step into a bad one; can loop persistently around a fundamentally mistaken plan, each iteration polishing an approach that was never going to work; can declare success when the goal is not actually met, because it reasoned that it was. The loop is a powerful engine of iteration wrapped around a fallible reasoner - which is why watching the reasoning, and verifying the result against reality rather than against the agent's own satisfaction, is not optional oversight but the core of using agents well.

Getting a feel for the shape of agentic reasoning - its real strengths and its characteristic failures - is the most valuable judgement in this module, because it is what tells you when to lean on an agent and when to lean in and check. On the strong side: agents are good at decomposing a fuzzy goal into a sensible structure; at breadth-first work that benefits from tireless iteration (gather widely, compare, synthesise); at applying a clear procedure across many cases; at catching their own obvious slips when reasoning out loud; and at recovering from local dead ends by trying another route. For the multi-step, tool-using, knowledge-heavy middle of design work, this is real and useful competence, and under-using it out of fear wastes a genuine capability.

On the failing side, the pattern that matters most is that the failures are *silent* - they do not announce themselves, because the agent has no reliable sense of its own correctness and expresses a wrong conclusion in the same confident register as a right one. The specific traps: confidently wrong plans, where the decomposition is subtly flawed and every well-executed step compounds the error; plausible-but-wrong reasoning, where each step sounds fine but the chain reaches a false conclusion (especially in anything numerical, causal, or dependent on a fact the model has misremembered); invalid steps followed with diligence, where the agent commits to a mistaken sub-goal and pursues it hard; premature success, where it decides the goal is met when it is not; and the persistent dead end, where the same adaptiveness that enables recovery instead has it circling a doomed approach, or wandering off task, without the self-doubt that would make a person stop and reconsider. None of these looks like an error while it is happening; all of them look like an agent working confidently.

The deeper point is that an agent's reasoning is not the same *kind* of thing as a professional's judgement, even when it resembles it. It has no stake in the outcome, no duty of care, no felt sense of when something is off, no real understanding of consequences - it is generating a plausible continuation of a reasoning-shaped text. It can be a superb aid to thinking and a tireless executor of well-structured work, but it is not a substitute for the judgement of someone who understands what is actually at stake, and it fails in ways that judgement is specifically needed to catch. This is why, however capable the planning becomes, the reasoning about whether the plan is *right for this project* - and the accountability for acting on it - stays with you. Delegate the planning; keep the judgement.

All of Module 1 comes together here in a set of practical habits for getting the benefit of agentic planning while catching its silent failures - habits that make you the director and verifier the work needs. The first is to read the plan before you trust the output. Because good agents reason out loud, you usually can see the decomposition and the logic; skim it early and you will often spot a flawed plan before the agent spends forty steps executing it, which is far cheaper than catching the error in the result. Do not wait for the finished work to judge whether the approach was sound; judge the approach when it is cheap to change.

The second is to verify against reality, not against the agent's own confidence. An agent declaring the goal met is not evidence the goal is met; a chain of reasoning sounding airtight is not evidence it is correct. Check the output against the world: does the figure actually add up (re-run it, or have a tool do it), does the cited source actually say that, does the design actually satisfy the constraint, does the conclusion actually follow. This is doubly important for the silent failures - the confidently wrong plan and the plausible-but-wrong chain - precisely because they give no internal signal; only contact with an external check exposes them. Pay closest attention to anything numerical, anything causal, and anything touching safety, code, cost or a commitment, where a silent reasoning error is most costly.

The third is to structure the task to make failure visible and recoverable. Give the agent a clear goal and clear success criteria so 'done' is something you can check, not just something it can assert. Scope large tasks into stages with checkpoints, so a wrong plan surfaces at a stage boundary rather than at the end. Ask the agent to state its plan and its assumptions before executing, so you can correct the premises. And keep the consequential decisions - what the plan should optimise for, whether an approach is acceptable, when the work is truly finished - as human decisions, because those are exactly the judgements the agent's reasoning cannot be relied on to make and cannot be made to own. Do these, and agentic planning becomes what it should be: a powerful engine for the multi-step work of design, directed and verified by the professional who remains the author and the architect of record.