[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"pack-detail-planning-agent-stack-fr":3,"seo:pack:planning-agent-stack:fr":102},{"code":4,"message":5,"data":6},200,"操作成功",{"pack":7},{"slug":8,"icon":9,"tone":10,"status":11,"status_label":12,"title":13,"description":14,"items":15,"install_cmd":101},"planning-agent-stack","🗺️","#7C3AED","new","Nouveau · cette semaine","Stack pour Agents avec Planification","Dix picks pour les devs qui construisent des agents plan-puis-exécution (ReAct, ReWOO, Plan-and-Solve) : frameworks de planning, décomposition de tâches, plans persistants, agents avec world model, et le harness d'eval qui prouve que le plan a tenu.",[16,28,38,46,54,62,69,79,86,94],{"id":17,"uuid":18,"slug":19,"title":20,"description":21,"author_name":22,"view_count":23,"vote_count":24,"lang_type":25,"type":26,"type_label":27},679,"958852ab-9d94-415e-91b3-a44c467c4e0a","ai-agent-design-patterns-architecture-guide-2026-958852ab","AI Agent Design Patterns — Architecture Guide 2026","Catalog of proven design patterns for building AI agents: ReAct, Plan-and-Execute, Reflection, Tool Use, Multi-Agent, Human-in-the-Loop, and more. With architecture diagrams and code examples.","Prompt Lab",173,0,"en","prompt","Prompt",{"id":29,"uuid":30,"slug":31,"title":32,"description":33,"author_name":34,"view_count":35,"vote_count":24,"lang_type":25,"type":36,"type_label":37},3536,"50242a81-80d4-5b73-bdbc-9b77950c219f","awesome-agentic-patterns-practical-blueprints","Awesome Agentic Patterns — Practical Blueprints","awesome-agentic-patterns is a curated catalogue of reusable agent patterns covering planning, tool use, memory, evaluation, and safety loops.","Agent Toolkit",89,"skill","Skill",{"id":39,"uuid":40,"slug":41,"title":42,"description":43,"author_name":44,"view_count":45,"vote_count":24,"lang_type":25,"type":36,"type_label":37},831,"b985ba42-4ba9-452d-93f1-9efa434df107","langgraph-build-stateful-ai-agent-workflows-b985ba42","LangGraph — Build Stateful AI Agent Workflows","Framework for building stateful, multi-step AI agent workflows as graphs. LangGraph enables cycles, branching, human-in-the-loop, and persistent state for complex agent systems.","LangChain",229,{"id":47,"uuid":48,"slug":49,"title":50,"description":51,"author_name":52,"view_count":53,"vote_count":24,"lang_type":25,"type":36,"type_label":37},204,"99cd6575-668b-4cbc-8b32-a3aa04138188","autogen-multi-agent-conversation-framework-99cd6575","AutoGen — Multi-Agent Conversation Framework","Microsoft framework for building multi-agent conversational AI systems. Agents chat with each other to solve tasks. Supports tool use, code execution, and human feedback. 56K+ stars.","Microsoft AI",160,{"id":55,"uuid":56,"slug":57,"title":58,"description":59,"author_name":60,"view_count":61,"vote_count":24,"lang_type":25,"type":36,"type_label":37},49,"36c7c41a-843f-43ce-a447-39c9004478af","claude-code-agent-task-decomposition-break-down-complex-36c7c41a","Claude Code Agent: Task Decomposition — Break Down Complex Tasks","Claude Code agent that breaks complex tasks into manageable subtasks. Plans execution order, identifies dependencies, and tracks progress.","Skill Factory",140,{"id":63,"uuid":64,"slug":65,"title":66,"description":67,"author_name":60,"view_count":68,"vote_count":24,"lang_type":25,"type":36,"type_label":37},472,"034be597-c361-45a2-b143-41cce0ec8ad8","planning-files-manus-style-persistent-planning-skill-034be597","Planning with Files — Manus-Style Persistent Planning Skill","Claude Code skill implementing persistent markdown planning with 96.7% benchmark pass rate. Uses a 3-file pattern (task_plan.md, findings.md, progress.md) to survive context resets.",226,{"id":70,"uuid":71,"slug":72,"title":73,"description":74,"author_name":75,"view_count":76,"vote_count":24,"lang_type":25,"type":77,"type_label":78},317,"a5444c0c-db82-473d-95f1-391d0a3daf3d","plandex-terminal-ai-large-codebases-a5444c0c","Plandex — Terminal AI for Large Codebases","Plandex is a terminal-based AI dev tool for large, multi-file coding tasks. 15.2K+ stars. 2M token context, sandbox diffs, auto-debug. MIT.","Script Depot",92,"script","Script",{"id":80,"uuid":81,"slug":82,"title":83,"description":84,"author_name":75,"view_count":85,"vote_count":24,"lang_type":25,"type":77,"type_label":78},3168,"3252ad99-8697-433a-a37c-37f7cfc6eb34","plannotator-visual-plan-diff-review-for-agents","Plannotator — Visual Plan & Diff Review for Agents","Plannotator is a plan + code review UI that lets you annotate agent plans and diffs as structured feedback across Claude Code, Codex, and Gemini CLI.",36,{"id":87,"uuid":88,"slug":89,"title":90,"description":91,"author_name":92,"view_count":93,"vote_count":24,"lang_type":25,"type":36,"type_label":37},3479,"24f9c660-5e73-58f7-be47-3b6a699405a4","agentic-world-modeling-research-directory","Agentic World Modeling — Research Directory","Research directory for agentic world modeling. Use it to map foundational papers, capability frameworks, and evaluation methods for world models in agents.","AI Open Source",71,{"id":95,"uuid":96,"slug":97,"title":98,"description":99,"author_name":34,"view_count":100,"vote_count":24,"lang_type":25,"type":36,"type_label":37},3153,"73cd67c3-9db6-48ed-8a31-c082f618168e","agent-evaluation-test-virtual-agents-in-ci","Agent Evaluation — Test Virtual Agents in CI","Agent Evaluation is a Python framework that runs repeatable, scored tests for virtual agents, so teams can catch regressions automatically in CI.",82,"tokrepo install pack\u002Fplanning-agent-stack",{"pageType":103,"pageKey":8,"locale":25,"title":104,"metaDescription":105,"h1":106,"tldr":107,"bodyMarkdown":108,"faq":109,"schema":125,"internalLinks":131,"citations":144,"wordCount":157,"generatedAt":158},"pack","Planning Agent Stack — 10 Picks for Plan-then-Execute Agents (ReAct, ReWOO, Plan-and-Solve)","AI Agent Design Patterns, Awesome Agentic Patterns, LangGraph, AutoGen, task decomposition, Manus-style file planning, Plandex, Plannotator, world modeling, agent eval — the stack for agents that plan before they act.","Planning Agent Stack — Plan-then-Execute Picks for Real Agents","Ten picks ordered by the actual build order of a planning agent: read the patterns (ReAct \u002F ReWOO \u002F Plan-and-Solve), pick a planning framework (LangGraph plan-execute or AutoGen GroupChat), wire a task-decomposition agent, persist the plan to disk, run the plan-execute loop on a real codebase, review the diff, model the world, and prove the plan was better with an eval harness. The lesson the hard way: an agent without a plan eval is just hope with a chat box.","## What's in this pack\n\nThis is the stack you build when the single-shot ReAct loop hits its first 30-step trajectory, drifts off goal at step 14, and you realize the agent never had a plan — it had momentum.\n\nEvery pick is for the dev shipping a **plan-then-execute agent**: the agent writes a plan, executes against it, then revises. That's the ReAct family (interleaved reason+act), ReWOO (plan everything up-front, no observations during planning), and Plan-and-Solve (decompose then solve each step). The picks cover the four layers that have to exist before any pattern ships: **pattern literacy**, **orchestration**, **decomposition + persistence**, and **review \u002F world model \u002F eval**.\n\nThis pack is **deliberately different** from the existing `multi-agent-frameworks` pack on TokRepo. That one is about *how multiple agents talk to each other* (CAMEL, LangGraph as orchestration, DeepAgents, GPT Researcher). This pack is about *how a single agent — or the planner inside a swarm — actually plans*. Zero overlapping workflow IDs.\n\n| # | Asset | Role in the planning loop |\n|---|---|---|\n| 1 | AI Agent Design Patterns | Pattern catalog: ReAct, ReWOO, Plan-and-Solve, Reflexion |\n| 2 | Awesome Agentic Patterns | Practical blueprints for planning + tool use |\n| 3 | LangGraph | Stateful plan-execute graph with checkpointing |\n| 4 | AutoGen | GroupChat-driven planning between specialized agents |\n| 5 | Task Decomposition (Claude Code Agent) | Subagent that splits a goal into ordered subtasks |\n| 6 | Planning with Files (Manus-style) | Persist plan.md to disk so the agent can resume |\n| 7 | Plandex | Reference plan-execute agent for large codebases |\n| 8 | Plannotator | Visual review of the plan + the diff it produced |\n| 9 | Agentic World Modeling | Research directory on agents that model environments |\n| 10 | Agent Evaluation | Test virtual agents in CI — proves the new plan was actually better |\n\n## Install in this order (read → orchestrate → decompose → persist → execute → review → eval)\n\n1. **AI Agent Design Patterns** — start here. Know the three families: **ReAct** interleaves Reason → Act → Observe (cheap, robust, drifts on long horizons); **ReWOO** plans every tool call up-front then executes (saves tokens, fragile to a bad first plan); **Plan-and-Solve** decomposes then solves each subtask (the default for long-horizon work).\n2. **Awesome Agentic Patterns** — once you know the patterns, you need the recipes. A blueprint directory for planning, tool use, reflection, and recovery. Use it as a lookup when you hit a design question.\n3. **LangGraph** — the orchestration framework most plan-execute agents end up on. Plan is a node, executor is a node, revision is a node; LangGraph carries state + checkpoints. Crash at step 17? Resume from the checkpoint. This pick is the workflow-focused entry, distinct from the orchestration entry in the multi-agent pack.\n4. **AutoGen** — when planning is a conversation (planner + critic + executor), GroupChat is the cleanest abstraction. Declare agents and a speaker policy; the framework runs the dialogue until the goal is reached. Use it for planning-via-conversation; use LangGraph when the plan is a graph.\n5. **Task Decomposition (Claude Code Agent)** — the subagent that does the actual decomposition. Drop it into `.claude\u002Fagents\u002F`, hand it a goal, get an ordered subtask list with dependencies. Production planners delegate this rather than asking the planner LLM to decompose mid-prompt.\n6. **Planning with Files** — Manus's signature trick: write the plan to a file the agent re-reads every turn. Ships `plan.md`, `progress.md`, append-only logs. The cheapest robustness upgrade in this pack — the agent literally can't lose track because it's reading from disk, not memory.\n7. **Plandex** — the reference plan-execute agent you can read the source of. Decompose a coding task, write a plan, execute step by step, ask for review at checkpoints. Run it on your own repo and watch the trajectory; it's the cheapest way to learn what a production planner looks like.\n8. **Plannotator** — once the agent has a plan and a diff, a human (or critic agent) reviews them side by side. Visual board: plan steps on one side, diff produced by each step on the other, inline annotation. Plug it between execute and merge.\n9. **Agentic World Modeling** — the frontier: agents that maintain an explicit world model (what's in the database, what files exist, what the user already said) so the plan is grounded in state, not hallucination. A curated research catalog — papers, benchmarks, codebases.\n10. **Agent Evaluation** — the loop closer. Without a plan eval, every prompt change is vibes. Scores trajectories on plan quality (was the plan optimal?), fidelity (did the agent follow it?), and outcome (was the goal met?). Run on every PR.\n\n## How they fit together (plan-then-execute loop)\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│  READ FIRST                                                 │\n│   AI Agent Design Patterns  ──►  ReAct \u002F ReWOO \u002F Plan-Solve │\n│   Awesome Agentic Patterns  ──►  named blueprints           │\n└─────────────────────────────────────────────────────────────┘\n                          │\n                          ▼\n┌─────────────────────────────────────────────────────────────┐\n│  ORCHESTRATE  →  DECOMPOSE  →  PERSIST                      │\n│   LangGraph (graph plan)  OR  AutoGen (dialogue plan)       │\n│        │                                                    │\n│        ▼                                                    │\n│   Task Decomposition agent  ──►  ordered subtask list       │\n│        │                                                    │\n│        ▼                                                    │\n│   Planning with Files       ──►  plan.md \u002F progress.md      │\n└─────────────────────────────────────────────────────────────┘\n                          │\n                          ▼\n┌─────────────────────────────────────────────────────────────┐\n│  EXECUTE  →  REVIEW  →  REPLAN                              │\n│   Plandex-style loop      ──►  step → tool → diff           │\n│   Plannotator             ──►  human\u002Fcritic reviews diff    │\n│   Agentic World Modeling  ──►  update state, replan if off  │\n└─────────────────────────────────────────────────────────────┘\n                          │\n                          ▼\n┌─────────────────────────────────────────────────────────────┐\n│  EVAL                                                       │\n│   Agent Evaluation  ◄── plan quality + fidelity + outcome   │\n│                          (runs on every PR in CI)           │\n└─────────────────────────────────────────────────────────────┘\n```\n\n**Read** is one-time. **Orchestrate \u002F decompose \u002F persist** is setup — done once per agent. **Execute \u002F review \u002F world model** is the hot loop per task. **Eval** wraps everything and is the only feedback signal that survives prompt drift, model swaps, and library upgrades.\n\n## Tradeoffs you'll hit\n\n- **ReAct vs ReWOO vs Plan-and-Solve.** ReAct is the easy default but burns tokens on long horizons. ReWOO front-loads the whole plan in one call (cheap, fast) but is brittle when the first observation invalidates it. Plan-and-Solve is the middle ground used by Manus, Plandex, and most production planners: decompose once, execute with light revision. Start with Plan-and-Solve unless you have a reason not to.\n- **LangGraph vs AutoGen for planning.** LangGraph treats the plan as a graph — state machine, checkpoints, deterministic pipelines. AutoGen treats it as a conversation — planner talks to executor talks to critic. Many mature setups use LangGraph as the outer graph and embed an AutoGen GroupChat inside one planner node.\n- **Plan in prompt vs plan on disk.** In-context is fast but you lose it on restart and risk context bloat after step 10. Writing `plan.md` \u002F `progress.md` to disk costs one tool call per turn but makes resumption, audit, and human override trivial. Default to disk for anything that runs more than ~10 minutes.\n- **Single planner LLM vs decomposition subagent.** One model doing decompose + execute + revise saves a hop but degrades on long lists — models under-decompose to look efficient. A dedicated subagent (own system prompt, lower temperature) produces flatter, more parallelizable lists. Use it when tasks routinely exceed ~5 subtasks.\n- **Plan eval vs outcome-only eval.** Outcome-only misses agents that stumbled into the right answer despite a terrible plan — they regress next month. Plan-only misses agents that wrote a beautiful plan and ignored it. Score both, separately. The CI harness in this pack does both.\n\n## Common pitfalls\n\n- **No replanning trigger.** A plan written at t=0 will be wrong by step 12 because the world changed. Build an explicit trigger — `if last_step_failed or world_state_diff > threshold then revise_plan`. Without it, agents march down dead trajectories until the budget runs out.\n- **Decomposition runaway.** Naive decomposers turn one task into 40 subtasks, each into 40 more. Cap recursion depth, cap subtask count, and pin \"prefer 3–7 subtasks at the top level\" into the system prompt.\n- **No plan persistence.** Crashing mid-run is not rare. Plan-only-in-context means starting over. Write it to a file from minute one.\n- **Plan + execute on the same model with no critic.** Planner biases toward plans the executor can do; executor biases toward executing whatever the planner says. Add a separate critic (different system prompt, ideally different model) whose only job is to flag bad plans before execution. AutoGen's GroupChat makes this trivial.\n- **Evaling the LLM not the trajectory.** Easy to test \"does the LLM output a plan that looks good\" and miss that the agent never followed it. Eval the trajectory: did the executed actions match the plan? When they diverged, was it justified?\n- **Confusing planning with multi-agent.** Many teams reach for a swarm when they needed a single planner with a good decomposer. Try plan-then-execute with one model first. Add a second agent only when you can name a specific role it plays (critic, world-model keeper, tool specialist).\n\n## When this pack alone isn't enough\n\nPlanning agents shine on long-horizon, multi-step, recoverable tasks. They lose on short latency-sensitive interactions (just ReAct it), tasks without a clear success criterion (build the eval first), and tasks where the executor is itself a swarm (install the `multi-agent-frameworks` pack alongside). The right adoption path: read the patterns guide, build the smallest plan-execute loop in LangGraph with file-persisted plans, run Plandex on a real repo to see what \"good\" looks like, then bolt on the eval harness before you touch the prompt a second time.",[110,113,116,119,122],{"q":111,"a":112},"How is this pack different from the existing `multi-agent-frameworks` pack on TokRepo?","Different layer of the stack. `multi-agent-frameworks` is about how multiple agents coordinate within one task — CAMEL roles, LangGraph as a team orchestrator, DeepAgents spawning sub-agents, GPT Researcher as a swarm reference. This pack is about how a single agent plans before it acts — pattern catalogs (ReAct\u002FReWOO\u002FPlan-and-Solve), task decomposition, plan persistence to disk, plan review, and agent eval. Zero overlapping workflow IDs. They pair well: install this pack for the planner, install `multi-agent-frameworks` if the executor is a team of agents.",{"q":114,"a":115},"Should I use LangGraph or AutoGen for planning?","LangGraph for plans that are graphs you can draw — deterministic pipelines, long-running jobs that need checkpointing, anything you want to resume after a crash. AutoGen for plans that emerge from a conversation between specialized agents — planner + critic + executor talking until consensus. Many production setups use LangGraph as the outer state machine and embed an AutoGen GroupChat inside one planner node when they need conversational planning for that step. Start with LangGraph; reach for AutoGen when the planning step itself benefits from multi-turn dialogue.",{"q":117,"a":118},"Is Manus-style plan-on-disk really worth the tool calls?","Yes for anything that runs more than about ten minutes. Two real wins: resumption (crash recovery is reading a file, not replaying a trajectory) and auditability (humans can read the plan and the progress log without parsing LLM context). The cost is one or two tool calls per turn to read and write `plan.md` \u002F `progress.md`, which is rounding error compared to the LLM call itself. For short interactive sessions it's overkill; for any long-horizon agentic loop it's the single highest-ROI reliability upgrade in this pack.",{"q":120,"a":121},"Why include both LangGraph here and in the multi-agent-frameworks pack?","Different workflow entries pointing at different facets of the same library. The multi-agent pack uses the orchestration-focused entry — LangGraph as the team coordinator. This pack uses the stateful-workflows entry — LangGraph as the plan-execute graph carrying one agent through many steps. Same library, different blueprints. You install LangGraph once; the two packs teach you two different ways to use it. Workflow IDs are distinct so there's no double-counting in your installed list.",{"q":123,"a":124},"What's the smallest viable agent-eval set I can start with?","Twenty to thirty hand-written trajectories is enough to detect regressions meaningfully. For each, record the goal, the ideal plan (your hand-written reference), the executed trajectory, and the outcome. Score three things separately: plan quality vs reference, fidelity (did execution follow the plan?), and outcome (was the goal met?). Build it in the first week before you tune the planner prompt. Every real production failure becomes one more case. By month three you'll have 100+ trajectories and every prompt change runs them in CI — that's the loop that drives planner quality, not vibes.",{"@context":126,"@type":127,"name":128,"description":129,"numberOfItems":130,"inLanguage":25},"https:\u002F\u002Fschema.org","ItemList","Planning Agent Stack","Ten picks for devs building plan-then-execute agents: planning patterns (ReAct, ReWOO, Plan-and-Solve), LangGraph and AutoGen frameworks, task decomposition, persistent file-based plans, plan review, world modeling, and agent eval.",10,[132,136,140],{"url":133,"anchor":134,"reason":135},"\u002Fen\u002Ftopics\u002Fmulti-agent-frameworks","Multi-Agent Frameworks pack","Companion pack — once your planner needs a team of executors, the multi-agent pack covers CAMEL, DeepAgents, and orchestration of multiple agents",{"url":137,"anchor":138,"reason":139},"\u002Fen\u002Ftopics\u002Fagent-memory-layer","Agent Memory Layer pack","Planning agents need persistent memory across runs — the memory pack covers Mem0, Zep, and other state stores that pair with plan-on-disk",{"url":141,"anchor":142,"reason":143},"\u002Fen\u002Ftopics\u002Fllm-observability","LLM Observability pack","Tracing a 30-step plan-execute trajectory without observability is impossible — pair this pack with Langfuse \u002F Phoenix \u002F AgentOps",[145,149,153],{"claim":146,"source_name":147,"source_url":148},"LangGraph supports stateful, checkpointed graph workflows for long-running agent runs","langchain-ai\u002Flanggraph on GitHub","https:\u002F\u002Fgithub.com\u002Flangchain-ai\u002Flanggraph",{"claim":150,"source_name":151,"source_url":152},"AutoGen provides a GroupChat abstraction for conversational multi-agent planning","microsoft\u002Fautogen on GitHub","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fautogen",{"claim":154,"source_name":155,"source_url":156},"Plandex implements a plan-then-execute agent loop over large codebases with reviewable checkpoints","plandex-ai\u002Fplandex on GitHub","https:\u002F\u002Fgithub.com\u002Fplandex-ai\u002Fplandex",1100,"2026-05-22T00:00:00Z"]