Hierarchical Planning
Purpose
[stub: hierarchical-planning]
Metadata
| Author | Amit Singh |
| Scope | agentic-ai-engineering |
Local graph
Linked from 4 notes
4. Task Decomposition
Covers strategies for breaking a complex goal into subtasks that can be assigned to different agents, and how decomposition granularity affects coordination overhead.
3. Planning
Covers agent planning strategies — task decomposition, hierarchical planning, and plan-and-execute versus ReAct-style interleaved planning — and the tradeoffs between upfront planning cost and adaptive replanning.
Agentic AI Engineering
A book-shaped table of contents for Agentic AI Engineering: where 'LLM application' becomes 'agent' — introduction to agentic AI, agent cognition, memory systems, planning & reasoning algorithms, tools & environment interaction, retrieval & knowledge systems, and context engineering. Book 2 of the AI Systems Engineering series.
2. Planner–Executor Pattern
Formalizes the planner–executor pattern — a planning component that decomposes a goal into a full upfront plan, and a separate executor that carries out each step — with applicability criteria, concrete failure modes, and how it composes with the rest of the pattern catalog.
Related notes
1. Chain of Thought
Covers Chain-of-Thought prompting -- eliciting intermediate reasoning steps before a final answer -- why it improves multi-step task performance, and its limits on tasks requiring backtracking or exploration.
10. Debate & Critic Agents
Covers multi-agent debate and critic architectures, where separate agent roles argue opposing positions or critique a proposer's output, and the evidence for when this improves answer quality over single-agent self-reflection.
5. Graph of Thoughts
Covers Graph-of-Thoughts reasoning, where intermediate thoughts can merge, refine, and feed back into each other as a DAG rather than a tree, and the problem classes where this generalization pays off over Tree-of-Thoughts.
9. LLM Compiler
Covers the LLM Compiler pattern -- planning a DAG of tool calls upfront and executing independent branches in parallel -- and the latency and cost wins over sequential ReAct-style execution for tasks with parallelizable sub-steps.