Planning
Planning is the scaffold an agent reasons inside. It is a prompt-level structure, chosen per agent, not something the framework decides for you.
The shapes behave differently in a way you can see in the transcript. A reason-and-act loop decides one step at a time, looks at the result, then decides the next — it adapts well when the world surprises it, and it can wander, re-checking things it already knew. A plan-then-execute scaffold writes the whole plan first and then works it — steadier and cheaper on a task with a known shape, worse when step three invalidates the plan and the agent keeps going anyway. A reflection scaffold makes the agent draft the deliverable, re-read it against the goal and revise once before delivering — the revise pass runs inside the loop's existing rounds, so it costs roughly one extra model round per run. A decompose scaffold splits the goal into named sub-tasks and works them one at a time before integrating; the sub-tasks are still worked inside the same run — no sub-agents are spawned.
None of these is simply more capable. They fail in different directions: the loop drifts, the plan commits, reflection pays an extra round for a draft that was already right, and decomposition adds structure a small task never needed. Which cost you can live with depends on the task, which is why this is a per-agent choice rather than a platform default.
Scaffolds in this deployment
Read from the planning-plugin registry at page load.
| ReAct (reason + act) | Reason and act interleaved: the agent thinks, calls a tool, reads the result and re-plans each round. The loop's native behaviour — no extra prompting. | available · default |
| Plan then execute | The agent writes a numbered, tool-aware plan first and then works it step by step in the same run. A prompt scaffold — no extra model round. | available |
| Reflection (draft, self-check, revise once) | The agent drafts the deliverable, re-reads it against the goal and revises once before delivering. A prompt scaffold run inside the loop's existing rounds — roughly one extra model round per run, no separate reviewer call. | available |
| Decompose (sub-tasks in one run) | Splits the goal into named sub-tasks, works each to completion, then integrates the parts — all inside the same run. A prompt scaffold: no sub-agents are spawned; true delegation is deferred. | available |
How to choose
If the task is a known sequence — check these sources, compare against yesterday, write it up — plan-then-execute usually costs less and rambles less. If the task genuinely branches on what it finds, the reason-and-act loop is the one that can change course.
Reflection earns its extra round on prose deliverables nobody is waiting on — a scheduled brief or digest, where a self-check against the goal catches the unsupported claim before it ships. It is the wrong spend on a watch alert, where the deliverable is a diff and per-run cost is the product.
Decomposition helps when the goal is really several goals — collect from three sources, compare, write it up — and the transcript shows the agent interleaving them badly. Be clear about what it is here: the sub-tasks are worked inside the same run; handing them to separate sub-agents is a different mechanism, and this deployment does not do that yet.
A useful tell: read a run's steps and ask whether the agent re-derived something it already had. Repeated re-checking is the loop wandering, and it's the clearest reason to try another scaffold. The opposite tell is an agent that finished a plan whose premise stopped being true halfway through.
The default is the loop, because an agent that adapts badly is easier to diagnose than one that confidently executes the wrong plan.
There is an automated experiment runner: each agent's Tuning page (under /u/agents) can sweep the model, memory, planning, retrieval and state axes on one fixed objective — the agent's own declared eval, which is never swept, while guardrails only observes. Its limits are stated plainly: a naive full grid, several runs per cell, stopped cleanly at a hard budget wall with partial results kept. It compares compositions; it does not invent them.