Big task into small steps
Hand an agent the goal "ship the launch email" and watch it stall. There's no
tool named ship_the_launch_email; the goal names an outcome, not an action.
The agent either freezes, or — worse — hallucinates one giant step and reports
"done" having sent nothing. A capable plan begins by dissolving that gap.
Decomposition is the move: turn one fuzzy goal into an ordered list of subtasks small enough that each maps to a single concrete action. "Ship the launch email" becomes draft the copy → add a call to action → proofread the draft → schedule the send. Each piece is verb-first and checkable — you can look at the result of "proofread the draft" and say whether it happened. That checkability is what makes a step doable; a vague subtask just defers the same stall to later.
Where do the subtasks come from? An LLM can propose them, but here the knowledge
lives in a small rulebook — a map from known goals to their ordered steps — with
a generic fallback (research → do the work → review) for goals it has never
seen. A rulebook is deterministic and auditable: the same goal always expands the
same way, which matters when a wrong plan costs a real send. The fallback is the
humility clause — it keeps an unknown goal from crashing the planner.
The starter cheats: subtasks = [goal] echoes the whole goal back as one step,
decomposing nothing. Look the goal up in the rulebook (use fallback when it's
missing), then print each subtask on its own line numbered from 1.. Done means
four numbered lines, not one.
A plan is just an ordered list of steps small enough to actually do — and big goals only become doable once you've broken them down.