hawkes.aiKey ideas
- The one idea — Faced with a goal too big for one step, an agent decomposes it into a tree of smaller subtasks, then works through them leaf by leaf with its loop — and re-plans as results come back.
- How it is shown — "Research competitors and write a report" splitting into subtasks, each branching further into single-tool-call leaves — a decomposition tree the agent executes bottom-up.
- The trap to avoid — Expecting the model to nail a big task in one shot, or trusting the first plan rigidly — plans must adapt as reality returns from the tools.
- What it sets up — Making a plan is easy; knowing each step actually worked is not.
How does an AI handle a job that's too big for one step? Same way you would — break it down, work the pieces, and re-plan when reality pushes back.
The one idea
Faced with a goal too big for one step, an agent decomposes it into a tree of smaller subtasks, then works through them leaf by leaf with its loop — and re-plans as results come back.
Give an agent a real goal, research our competitors and write a report, and it hits a wall. That's too big for one tool call. So before acting, it does what you would: it breaks the giant task into smaller pieces. It makes a plan. Planning here is just decomposition. The agent splits the big goal into subtasks: find the competitors, gather data on each, compare them, write the report. A job too big to do at once becomes a short list of doable steps. The mountain becomes stairs. And subtasks split further.
How it works — the demo
"Research competitors and write a report" splitting into subtasks, each branching further into single-tool-call leaves — a decomposition tree the agent executes bottom-up.
Gather data breaks into one lookup per company; compare breaks into pricing, features, reviews. You get a tree: the goal at the top, branching into subtasks, down to small leaf actions, each one a single tool call. Then it works the tree. Using its loop, think, act, observe, the agent handles one leaf at a time: do the subtask, see the result, move on. A huge goal gets done not in one leap, but as a sequence of small, reachable steps. There are two styles. Plan-first: write the whole plan, then execute. Or interleaved: plan a little, act, see what comes back, adjust. Real agents mix them, because the first plan is a guess, and results often change what the next step should be.
The trap to avoid
Expecting the model to nail a big task in one shot, or trusting the first plan rigidly — plans must adapt as reality returns from the tools.
Why it matters — and what’s next
Making a plan is easy; knowing each step actually worked is not.
The trap: expecting a big task done in one shot, or trusting the first plan like gospel. Big goals need decomposition, and plans must adapt as results return. A plan is a starting map, not a fixed track. Good agents re-plan when the ground shifts. So an agent tackles a big task by breaking it into a tree of small ones, then working them with its loop, re-planning as it learns. But making a plan is easy; knowing each step actually worked is not. How does an agent check its own work? Next group.
This is one short episode in AI: Zero → Frontier, a step-by-step climb through how AI actually works. Each episode builds only on the ones before it.
Full transcript 2:30 of narration
Give an agent a real goal, research our competitors and write a report, and it hits a wall. That's too big for one tool call. So before acting, it does what you would: it breaks the giant task into smaller pieces. It makes a plan.
Planning here is just decomposition. The agent splits the big goal into subtasks: find the competitors, gather data on each, compare them, write the report. A job too big to do at once becomes a short list of doable steps. The mountain becomes stairs.
And subtasks split further. Gather data breaks into one lookup per company; compare breaks into pricing, features, reviews. You get a tree: the goal at the top, branching into subtasks, down to small leaf actions, each one a single tool call.
Then it works the tree. Using its loop, think, act, observe, the agent handles one leaf at a time: do the subtask, see the result, move on. A huge goal gets done not in one leap, but as a sequence of small, reachable steps.
There are two styles. Plan-first: write the whole plan, then execute. Or interleaved: plan a little, act, see what comes back, adjust. Real agents mix them, because the first plan is a guess, and results often change what the next step should be.
The trap: expecting a big task done in one shot, or trusting the first plan like gospel. Big goals need decomposition, and plans must adapt as results return. A plan is a starting map, not a fixed track. Good agents re-plan when the ground shifts.
So an agent tackles a big task by breaking it into a tree of small ones, then working them with its loop, re-planning as it learns. But making a plan is easy; knowing each step actually worked is not. How does an agent check its own work? Next group.