Prompt Decomposition Engines: State of the Art

Survey Date: April 6, 2026 Survey Type: Technical Literature Review Context: IAIP Polyphonic Discussion — PDE Technical Survey Agent Scope: Systems, architectures, benchmarks (excludes philosophical and linguistic analysis)

Key Findings

1. Task decomposition has become the central cognitive primitive of LLM-based agent systems. Every major agent framework (2023–2026) implements some form of complex-task-to-subtask breakdown, making decomposition the de facto interface between human intent and machine execution (Huang et al., 2024; Luo et al., 2025).

2. Two fundamental decomposition paradigms have emerged: decomposition-first and interleaved decomposition. Decomposition-first systems (HuggingGPT, TaskMatrix.AI, MetaGPT) generate a complete plan before execution. Interleaved systems (ReAct, Reflexion, LATS) alternate between planning and execution, adapting decomposition in real-time (Huang et al., 2024).

3. Tree-search-based decomposition represents the current performance frontier. LATS (Zhou et al., 2024) and ToolChain* (Zhuang et al., 2024) model decomposition as combinatorial search over action/tool spaces, using Monte Carlo Tree Search and A* respectively, achieving state-of-the-art results on programming and web navigation benchmarks.

4. Multi-agent systems have transformed decomposition from an individual cognitive task into an organizational one. MetaGPT (Hong et al., 2024), ChatDev (Qian et al., 2024), and CAMEL (Li et al., 2023) distribute decomposition across role-specialized agents, mimicking human team structures with SOPs, role assignment, and inter-agent validation.

5. The field is undergoing a paradigm shift from "prompt engineering" to "context engineering." Anthropic's 2025 framing positions the challenge not as crafting better prompts, but as curating the entire informational environment (history, tools, memory, runtime state) that the model processes at each inference step—reporting up to 54% improvement in agentic benchmark performance.

6. Decomposed Prompting (DecomP) established the theoretical foundation. Khot et al. (2023) demonstrated that modular decomposition of complex tasks into sub-task-specific prompts, each handled by specialized handlers, consistently outperforms monolithic prompting strategies on compositional reasoning tasks.

7. DSPy represents a paradigm shift toward programmatic, self-optimizing decomposition. Rather than hand-crafting decomposition prompts, DSPy (Khattab et al., 2023) compiles declarative Python programs into optimized LLM call sequences, enabling learned rather than designed decomposition strategies.

8. Conversational decomposition is emerging as a distinct paradigm. Systems like ACT (Google, 2025) and FATA (2025) teach agents to decompose tasks through dialogue—asking clarifying questions, negotiating scope, and iteratively refining understanding before acting—rather than processing monolithic instructions.

9. Existing benchmarks evaluate task completion but not decomposition quality per se. SWE-bench, GAIA, WebArena, AgentBench, and ToolBench measure end-to-end agent performance; none directly evaluates the quality, granularity, or appropriateness of the decomposition itself.

10. The recursive autonomous agent model (AutoGPT/BabyAGI) demonstrated the power and limitations of unbounded decomposition. These systems showed that recursive self-prompting can solve multi-step tasks but also revealed failure modes: error loops, hallucination cascades, and inefficient decomposition spirals.

System Taxonomy

By Architecture Type

By Decomposition Strategy

By Paradigm (Structured → Conversational Spectrum)

STRUCTURED ◄──────────────────────────────────────────────► CONVERSATIONAL

JSON schemas     Fixed pipelines    Role-play dialogues    Clarifying questions
DecomP           HuggingGPT         CAMEL                  ACT (Google)
TaskMatrix.AI    MetaGPT            AutoGen                FATA
DSPy             LangChain          ChatDev                Tri-Agent Eval
ToolChain*       Semantic Kernel    AgentVerse             (emerging 2025-26)
                 CrewAI Flows       Reflexion

The Conversational Turn

Evidence of the Paradigm Shift

The field shows a clear evolutionary trajectory from structured, programmatic decomposition toward conversational, dialogical decomposition. This section documents the specific evidence.

Phase 1: Structured Decomposition (2022–2023)

• DecomP (Khot et al., 2023): Decomposition as a modular program—each sub-task mapped to a handler function. Purely structural.
• HuggingGPT (Shen et al., 2023): LLM generates a JSON-structured task plan with explicit dependencies. No dialogue.
• TaskMatrix.AI (Liang et al., 2023): Structured action code generated from user input; APIs selected via documentation matching.
• BabyAGI (Nakajima, 2023): Task lists managed programmatically; no conversational negotiation of task scope.

Phase 2: Role-Play Decomposition (2023–2024)

• CAMEL (Li et al., 2023): Introduced "inception prompting"—agents prompt each other in role-play conversations. Decomposition emerges from dialogue between AI-user and AI-assistant agents. First major system where decomposition is conversational rather than purely structural.
• MetaGPT (Hong et al., 2024): While using SOPs, agents communicate via structured messages that include natural-language justifications. Hybrid structured-conversational.
• ChatDev (Qian et al., 2024): "Communicative dehallucination"—agents clarify and validate uncertain outputs through dialogue chains. Decomposition includes explicit clarification protocols.
• AutoGen (Microsoft, 2024): Conversation-centric architecture where task decomposition emerges from asynchronous message-passing between agents. Decomposition is literally a conversation.
• AgentVerse (Chen et al., 2023): Dynamic expert recruitment and collaborative decision-making through structured inter-agent communication.

Phase 3: Inquiry-Based Decomposition (2025–2026)

• ACT — Action-Based Contrastive Self-Training (Google, 2025): RL-trained agents learn when and how to ask clarifying questions during multi-turn task dialogue. Decomposition becomes implicit in the clarification process.
• FATA — First Ask Then Answer (Beijing IST, 2025): Agents proactively generate comprehensive clarification checklists before producing any answer, covering multiple dimensions of ambiguity. Decomposition reframed as structured inquiry.
• Tri-Agent Evaluation Framework (KDD 2025): Three-agent system (Question Clarifying Agent, Respondent Agent, Evaluator Agent) for benchmarking clarification capabilities. Decomposition quality measured through dialogue quality.
• Context Engineering (Anthropic, 2025): Reframes the entire problem from "what prompt to write" to "what context to curate at each step." Decomposition becomes dynamic context management—inherently conversational and stateful.

The Pattern

The shift is from decomposition-as-instruction (tell the machine what to do, step by step) toward decomposition-as-inquiry (the machine asks what needs to be done, collaboratively refining understanding). This represents a fundamental change in the locus of agency: from human-designed decomposition executed by machines, to machine-initiated decomposition refined through dialogue.

Key Systems (Annotated)

1. DecomP — Decomposed Prompting

• Citation: Khot, T., Trivedi, H., Finlayson, M., et al. (2023). "Decomposed Prompting: A Modular Approach for Solving Complex Tasks." ICLR 2023. arXiv:2210.02406
• Architecture: Modular prompt pipeline. A decomposer prompt generates sub-tasks; each sub-task is handled by a specialized prompt handler. Handlers can be recursive, symbolic, or LLM-based.
• Decomposition Strategy: Decomposition-first, modular. Sub-task handlers form a library that can be independently optimized, swapped, or augmented with symbolic modules.
• Evaluation: Outperforms CoT and few-shot baselines on symbolic reasoning, multi-hop QA, and long-context tasks.
• Paradigm: Structured (programmatic decomposition).

2. HuggingGPT

• Citation: Shen, Y., Song, K., Tan, X., et al. (2023). "HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face." NeurIPS 2023. arXiv:2303.17580
• Architecture: Four-stage pipeline: Task Planning → Model Selection → Task Execution → Response Generation. LLM (ChatGPT) as central controller; Hugging Face models as specialist executors.
• Decomposition Strategy: Decomposition-first. LLM analyzes user request and generates structured subtask list with dependencies, then selects optimal model for each subtask.
• Evaluation: Demonstrated multi-modal task composition (vision + text + audio). Bottlenecked by controller LLM inference latency and context length limits.
• Paradigm: Structured (JSON task plans).

3. TaskMatrix.AI

• Citation: Liang, Y., Wu, C., Song, T., et al. (2023). "TaskMatrix.AI: Completing Tasks by Connecting Foundation Models with Millions of APIs." arXiv:2303.16434
• Architecture: Conversational Foundation Model + API Platform + API Selector + Action Executor. LLM generates structured action code; API Selector matches subtasks to APIs via documentation.
• Decomposition Strategy: Decomposition-first with API-oriented subtask formulation. Scalable to millions of APIs.
• Evaluation: Demonstrated across digital (PowerPoint, web) and physical (robotics) domains.
• Paradigm: Structured (API action code generation).

4. Chameleon

• Citation: Lu, P., Peng, B., Cheng, H., et al. (2024). "Chameleon: Plug-and-Play Compositional Reasoning with Large Language Models." arXiv:2304.09842
• Architecture: LLM Planner generates execution sequences ("programs") composing heterogeneous tools (vision models, web search, Python, retrievers). Plug-and-play modularity.
• Decomposition Strategy: Decomposition-first with adaptive tool composition. The LLM considers which tool sequence best addresses each query.
• Evaluation: Outperforms static LLM chains on ScienceQA (+11.37%) and TabMWP (+17.0%).
• Paradigm: Structured (program synthesis for tool composition).

5. DEPS — Describe, Explain, Plan, Select

• Citation: Wang, Z., Cai, S., Chen, G., et al. (2023). "Describe, Explain, Plan and Select: Interactive Planning with Large Language Models Enables Open-World Multi-Task Agents." NeurIPS 2023. arXiv:2302.01560
• Architecture: Four-phase interactive loop: Describe (log environment state) → Explain (diagnose failures) → Plan (generate/revise sub-goals) → Select (rank sub-tasks by estimated difficulty via trainable goal selector).
• Decomposition Strategy: Interleaved with feedback. Plans are revised in response to execution failures via explicit self-explanation.
• Evaluation: Achieved ~2× performance improvement on 70+ Minecraft tasks vs. prior baselines. Generalized to ALFWorld and tabletop manipulation.
• Paradigm: Hybrid (structured planning with conversational self-explanation).

6. ToolChain*

• Citation: Zhuang, Y., Yu, Y., Wang, K., et al. (2024). "ToolChain*: Efficient Action Space Navigation in Large Language Models with A* Search." ICLR 2024. arXiv:2310.13227
• Architecture: Models tool-use planning as tree search. Each node = API/tool invocation; edges = subtask transitions. A* search with LLM-estimated heuristic costs guides exploration.
• Decomposition Strategy: Search-based. The tree structure naturally represents hierarchical task decomposition. A* pruning avoids suboptimal decomposition paths.
• Evaluation: +3.1% planning success, +3.5% reasoning accuracy over baselines; 2.31–7.35× computation reduction.
• Paradigm: Structured (search-based decomposition).

7. ReAct

• Citation: Yao, S., Zhao, J., Yu, D., et al. (2023). "ReAct: Synergizing Reasoning and Acting in Language Models." ICLR 2023. arXiv:2210.03629
• Architecture: Interleaved Thought-Action-Observation loop. Agent reasons about current state, takes an action (tool call, search), observes result, and iterates.
• Decomposition Strategy: Interleaved. No explicit decomposition phase; decomposition emerges from the reasoning trace as the agent identifies what to do next.
• Evaluation: Strong performance on HotpotQA, FEVER, ALFWorld, WebShop. Transparent reasoning via explicit thought traces.
• Paradigm: Hybrid (minimal structure, emergent decomposition).

8. Reflexion

• Citation: Shinn, N., Cassano, F., Gopinath, A., et al. (2023). "Reflexion: Language Agents with Verbal Reinforcement Learning." NeurIPS 2023. arXiv:2303.11366
• Architecture: ReAct loop augmented with self-reflective critique. After failure, agent generates verbal self-assessment explaining what went wrong, stored in episodic memory.
• Decomposition Strategy: Interleaved with error-driven refinement. Decomposition is revised through reflection—failures trigger re-decomposition.
• Evaluation: 91% pass@1 on HumanEval (code generation); significant improvements on ALFWorld and WebShop over ReAct baseline.
• Paradigm: Hybrid (conversational self-critique).

9. LATS — Language Agent Tree Search

• Citation: Zhou, A., Yan, K., Shlapentokh-Rothman, M., et al. (2024). "Language Agent Tree Search Unifies Reasoning, Acting, and Planning in Language Models." ICML 2024. arXiv:2310.04406
• Architecture: Combines ReAct + Reflexion + Monte Carlo Tree Search. Builds a search tree of possible reasoning/action trajectories. LLM-based value function scores intermediate nodes.
• Decomposition Strategy: Search-based. Systematically generates and explores multiple alternative step-wise decompositions, selecting optimal paths via value evaluation and reflective feedback.
• Evaluation: SOTA on HumanEval (programming), WebShop (web navigation). Outperforms ReAct, Reflexion, and CoT across multiple benchmarks.
• Paradigm: Structured (systematic search over decomposition space).

10. Voyager

• Citation: Wang, G., Xie, Y., Jiang, Y., et al. (2023). "Voyager: An Open-Ended Embodied Agent with Large Language Models." arXiv:2305.16291
• Architecture: Three components: Automatic Curriculum (proposes increasingly complex tasks), Skill Library (stores reusable code skills), Iterative Prompting (environment feedback + execution errors + self-verification).
• Decomposition Strategy: Curriculum-driven. Decomposes goals into sub-goals via skill retrieval and composition. Lifelong learning enables increasingly sophisticated decomposition.
• Evaluation: 3.3× more unique items obtained, 15.3× longer travel distance vs. baselines in Minecraft. Substantially outperforms ReAct, Reflexion, AutoGPT.
• Paradigm: Hybrid (emergent skill-based decomposition with feedback).

11. AutoGPT

• Citation: Richards, T. (2023). AutoGPT. GitHub: github.com/Significant-Gravitas/AutoGPT. 160k+ stars.
• Architecture: Recursive self-prompting loop: Goal → Plan subtasks → Execute → Evaluate → Adjust. Multimodal inputs, web browsing, code execution, plugin system, short-term + long-term (vector DB) memory.
• Decomposition Strategy: Recursive self-prompting. The agent generates its own decomposition prompts in each loop iteration.
• Evaluation: No formal benchmarks; demonstrated capability on open-ended tasks but prone to error loops and hallucination cascades.
• Paradigm: Structured (recursive programmatic decomposition).

12. BabyAGI

• Citation: Nakajima, Y. (2023). BabyAGI. GitHub: github.com/yoheinakajima/babyagi. 20k+ stars (archived 2024).
• Architecture: Three-agent loop: Task Execution Agent → Task Creation Agent → Task Prioritization Agent. Vector memory (Pinecone) for context accumulation.
• Decomposition Strategy: Recursive. Each completed task generates new sub-tasks; priority queue manages execution order.
• Evaluation: Proof-of-concept; influential for demonstrating recursive autonomous decomposition but limited practical reliability.
• Paradigm: Structured (programmatic task queue).

13. MetaGPT

• Citation: Hong, S., Zhuge, M., Chen, J., et al. (2024). "MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework." ICLR 2024. arXiv:2308.00352
• Architecture: Assembly-line multi-agent system with role-specialized agents (Product Manager, Architect, Engineer, QA). Standardized Operating Procedures (SOPs) encoded in prompts. Schema-based structured outputs at each stage.
• Decomposition Strategy: SOP-driven. Product Manager decomposes requirements into subtasks routed through role-based pipeline with intermediate verification.
• Evaluation: Higher coherence and executability on collaborative software engineering tasks vs. single-agent baselines. Executable feedback loop for code tasks.
• Paradigm: Structured (SOP-driven organizational decomposition).

14. ChatDev

• Citation: Qian, C., Cong, X., Yang, C., et al. (2024). "ChatDev: Communicative Agents for Software Development." ACL 2024. GitHub: github.com/OpenBMB/ChatDev.
• Architecture: Multi-agent software development platform with role assignment (designer, coder, tester). Natural language communication chains with formal/structured message options.
• Decomposition Strategy: Communicative. Agents decompose through dialogue chains with "communicative dehallucination"—agents validate and request clarification on uncertain outputs.
• Evaluation: Zero-code agent setup via YAML/UI config. Reduced error propagation through inter-agent validation.
• Paradigm: Hybrid (structured roles with conversational clarification protocols).

15. CAMEL

• Citation: Li, G., Hammoud, H., Itani, H., et al. (2023). "CAMEL: Communicative Agents for 'Mind' Exploration of Large Language Model Society." NeurIPS 2023. arXiv:2303.17760
• Architecture: Role-playing framework with inception prompting. Two or more agents engage in structured role-play dialogue (e.g., AI-user and AI-assistant) to solve tasks collaboratively.
• Decomposition Strategy: Inception/dialogical. Task decomposition emerges from the conversational dynamic between role-playing agents. Agents prompt each other, generating decomposition through dialogue rather than explicit planning.
• Evaluation: Outperforms single-agent chat models on task completion and quality (human + GPT-4 evaluation).
• Paradigm: Conversational (decomposition through inter-agent dialogue).

16. AgentVerse

• Citation: Chen, W., Su, Y., Zuo, J., et al. (2023). "AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors." arXiv:2308.10848
• Architecture: Four-phase cycle: Expert Recruitment → Collaborative Decision-Making → Action Execution → Evaluation. Dynamic group composition with horizontal and vertical communication.
• Decomposition Strategy: Dynamic collaborative. Agents are recruited based on task requirements; decomposition emerges from group deliberation and structured communication.
• Evaluation: Outperforms single-agent baselines in reasoning, coding, tool use, and embodied AI tasks.
• Paradigm: Hybrid (structured phases with conversational collaboration).

17. AutoGen (Microsoft)

• Citation: Wu, Q., Bansal, G., Zhang, J., et al. (2023). "AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation." arXiv:2308.08155. v0.4 released late 2024.
• Architecture: Conversation-centric, event-driven, asynchronous runtime. Agents (planner, researcher, executor, critic) exchange messages; flexible collaboration patterns. Supports human-in-the-loop.
• Decomposition Strategy: Emergent conversational. Task decomposition arises from message-passing between agents. Planner agents break tasks into subtasks via dialogue with executor agents.
• Evaluation: Widely adopted for research and prototyping. In late 2025, integrated into Microsoft's broader Agent Framework.
• Paradigm: Conversational (decomposition as multi-agent conversation).

18. CrewAI

• Citation: CrewAI (2024). docs.crewai.com. GitHub: github.com/crewai/crewai.
• Architecture: Role-based teams ("Crews") with deterministic Flows for agent orchestration. Manager/planner agents assign and route subtasks. Supports hierarchical decomposition.
• Decomposition Strategy: Deterministic and hierarchical via Flows. Explicit task splitting with guardrails and human-in-the-loop triggers.
• Evaluation: Production-grade features (RBAC, monitoring, traceability). Enterprise-focused.
• Paradigm: Structured (deterministic flows with role-based decomposition).

19. LangChain / LangGraph

• Citation: LangChain (2022–present). docs.langchain.com. GitHub: github.com/langchain-ai/langchain. 95k+ stars.
• Architecture: Modular chains linking models, prompts, retrievers, tools, and memory. LangGraph (2024) adds stateful, event-driven, cyclical agent loops with deterministic control.
• Decomposition Primitives: Chains (linear), Graphs (cyclical/branching), Agents (tool-using loops), Memory (context persistence), Human-in-the-loop checkpoints.
• Paradigm: Framework (supports both structured and conversational decomposition patterns).

20. DSPy

• Citation: Khattab, O., et al. (2023). "DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines." Stanford NLP. GitHub: github.com/stanfordnlp/dspy.
• Architecture: Declarative modules compiled into optimized LLM call sequences. Programmatic optimization auto-tunes prompts and workflows based on metrics and feedback.
• Decomposition Strategy: Compiled/programmatic. Developer declares modular pipeline; DSPy optimizes the decomposition and prompting strategy automatically.
• Evaluation: ~3–4ms framework overhead. Strong results on multi-stage RAG and reasoning pipelines through end-to-end optimization.
• Paradigm: Structured (programmatic, but with learned/adaptive decomposition).

21. Semantic Kernel

• Citation: Microsoft (2023–present). Semantic Kernel. GitHub: github.com/microsoft/semantic-kernel.
• Architecture: Kernel runtime + Plugins (semantic/native functions) + Planners + Memory. Deep .NET/Azure integration.
• Decomposition Primitives: Planner plugins allow LLMs to dynamically generate structured executable plans. Function calling for subtask delegation.
• Paradigm: Structured (planner-based dynamic decomposition).

Benchmark Landscape

Major Benchmarks

SOTA Scores (as of early 2026)

What Benchmarks Miss

1. Decomposition quality is never directly measured. All benchmarks evaluate end-to-end task completion. A system that produces an elegant, minimal decomposition scores the same as one that uses a wasteful, redundant decomposition—as long as both succeed.

2. No benchmarks for decomposition appropriateness. Whether the granularity of decomposition matches the task complexity is not measured. Over-decomposition (breaking simple tasks into too many steps) and under-decomposition (attempting complex tasks monolithically) are invisible.

3. Cost and efficiency of decomposition are secondary. SWE-bench tracks cost per trajectory in some leaderboards, but decomposition-specific compute overhead (planning tokens, search breadth) is not isolated.

4. Conversational decomposition has no benchmark. ClarQ4LLM benchmarks clarification quality but not task decomposition through dialogue. No benchmark tests whether an agent can collaboratively refine task scope through conversation.

5. Error recovery during decomposition is not evaluated. Benchmarks are largely single-shot. The ability to detect a bad decomposition mid-execution and restructure is not tested.

6. Decomposition transferability is unknown. Whether decomposition strategies learned on one domain transfer to another is not systematically evaluated.

Open Problems & Research Gaps

Technical Challenges

1. Decomposition Quality Metrics. There is no established metric for decomposition quality independent of task completion. Developing such metrics—measuring granularity appropriateness, dependency correctness, parallelizability, and cognitive load—is a critical open problem.

2. Optimal Decomposition Granularity. When should a system decompose further vs. attempt direct execution? The trade-off between decomposition depth and execution efficiency is poorly understood. Too-fine decomposition wastes tokens and introduces coordination overhead; too-coarse decomposition exceeds LLM capability per step.

3. Dynamic Re-Decomposition. Most systems commit to a decomposition. Graceful mid-execution re-decomposition—detecting that the current plan is failing and restructuring—remains a frontier challenge. DEPS and Reflexion approach this but through reflection rather than true re-planning.

4. Decomposition Under Ambiguity. When user intent is ambiguous, should the system decompose based on the most likely interpretation, or should it first resolve ambiguity? The ACT and FATA work opens this question but does not resolve it architecturally.

5. Multi-Modal Decomposition. Current decomposition strategies are overwhelmingly text-centric. How to decompose tasks that span text, vision, audio, and physical action (robotics) into coherent multi-modal sub-task sequences is underdeveloped.

6. Decomposition Verification. How does a system verify that a proposed decomposition is correct and complete before execution? MetaGPT's intermediate verification is a step, but formal verification of decomposition plans remains unexplored.

7. Collaborative Decomposition Protocols. When multiple agents (or an agent and a human) collaborate on decomposition, what communication protocols ensure efficient, unambiguous task allocation? This is the organizational design problem translated to AI systems.

8. Context Window Limits as Decomposition Constraints. As tasks grow complex, the decomposition plan itself may exceed context window limits. How to manage decomposition state across context boundaries—compaction, summarization, external memory—is an active engineering challenge.

9. Decomposition Fairness and Bias. Does the way an LLM decomposes tasks reflect biases in its training data? If a system consistently decomposes tasks in a culturally specific way, this may disadvantage users from other contexts. Entirely uninvestigated.

10. The Conversational Decomposition Gap. Despite the evidence of systems moving toward conversational decomposition, there is no theoretical framework for when decomposition should be conversational vs. structured. No formal model describes the conditions under which inquiry-based decomposition outperforms instruction-based decomposition.

Research Directions

• Benchmarks for decomposition quality (independent of task success)
• Formal models of decomposition optimality (information-theoretic or decision-theoretic)
• Hybrid structured-conversational decomposition (knowing when to ask vs. when to plan)
• Cross-domain decomposition transfer learning
• Human-AI collaborative decomposition protocols (beyond human-in-the-loop approval)
• Decomposition-aware context engineering (managing decomposition state within limited context windows)

Sources

Foundational Papers

1. Khot, T., Trivedi, H., Finlayson, M., et al. (2023). "Decomposed Prompting: A Modular Approach for Solving Complex Tasks." ICLR 2023. https://arxiv.org/abs/2210.02406

2. Shen, Y., Song, K., Tan, X., et al. (2023). "HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face." NeurIPS 2023. https://arxiv.org/abs/2303.17580

3. Liang, Y., Wu, C., Song, T., et al. (2023). "TaskMatrix.AI: Completing Tasks by Connecting Foundation Models with Millions of APIs." https://arxiv.org/abs/2303.16434

4. Lu, P., Peng, B., Cheng, H., et al. (2024). "Chameleon: Plug-and-Play Compositional Reasoning with Large Language Models." https://chameleon-llm.github.io/

5. Wang, Z., Cai, S., Chen, G., et al. (2023). "Describe, Explain, Plan and Select: Interactive Planning with Large Language Models Enables Open-World Multi-Task Agents." NeurIPS 2023. https://arxiv.org/abs/2302.01560

6. Zhuang, Y., Yu, Y., Wang, K., et al. (2024). "ToolChain*: Efficient Action Space Navigation in Large Language Models with A* Search." ICLR 2024. https://arxiv.org/abs/2310.13227

Agent Architecture Papers

7. Yao, S., Zhao, J., Yu, D., et al. (2023). "ReAct: Synergizing Reasoning and Acting in Language Models." ICLR 2023. https://arxiv.org/abs/2210.03629

8. Shinn, N., Cassano, F., Gopinath, A., et al. (2023). "Reflexion: Language Agents with Verbal Reinforcement Learning." NeurIPS 2023. https://arxiv.org/abs/2303.11366

9. Zhou, A., Yan, K., Shlapentokh-Rothman, M., et al. (2024). "Language Agent Tree Search Unifies Reasoning, Acting, and Planning in Language Models." ICML 2024. https://arxiv.org/abs/2310.04406

10. Wang, G., Xie, Y., Jiang, Y., et al. (2023). "Voyager: An Open-Ended Embodied Agent with Large Language Models." https://arxiv.org/abs/2305.16291

Multi-Agent Papers

11. Li, G., Hammoud, H., Itani, H., et al. (2023). "CAMEL: Communicative Agents for 'Mind' Exploration of Large Language Model Society." NeurIPS 2023. https://arxiv.org/abs/2303.17760

12. Hong, S., Zhuge, M., Chen, J., et al. (2024). "MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework." ICLR 2024. https://arxiv.org/abs/2308.00352

13. Qian, C., Cong, X., Yang, C., et al. (2024). "ChatDev: Communicative Agents for Software Development." ACL 2024. https://github.com/OpenBMB/ChatDev

14. Chen, W., Su, Y., Zuo, J., et al. (2023). "AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors." https://arxiv.org/abs/2308.10848

15. Wu, Q., Bansal, G., Zhang, J., et al. (2023). "AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation." https://arxiv.org/abs/2308.08155

Frameworks & Tools

16. LangChain. https://docs.langchain.com / https://github.com/langchain-ai/langchain

17. Khattab, O., et al. (2023). "DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines." https://github.com/stanfordnlp/dspy

18. Microsoft Semantic Kernel. https://github.com/microsoft/semantic-kernel

19. CrewAI. https://docs.crewai.com / https://github.com/crewai/crewai

20. Richards, T. (2023). AutoGPT. https://github.com/Significant-Gravitas/AutoGPT

21. Nakajima, Y. (2023). BabyAGI. https://github.com/yoheinakajima/babyagi

Benchmark Papers

22. Jimenez, C. E., Yang, J., Wettig, A., et al. (2024). "SWE-bench: Can Language Models Resolve Real-World GitHub Issues?" https://www.swebench.com / https://github.com/swe-bench/SWE-bench

23. Mialon, G., Dessì, R., Lomeli, M., et al. (2023). "GAIA: A Benchmark for General AI Assistants." https://huggingface.co/gaia-benchmark

24. Zhou, S., Xu, F. F., Zhu, H., et al. (2023). "WebArena: A Realistic Web Environment for Building Autonomous Agents." https://webarena.dev

25. Liu, X., Yu, H., Zhang, H., et al. (2024). "AgentBench: Evaluating LLMs as Agents." ICLR 2024. https://arxiv.org/abs/2308.03688

26. Qin, Y., Liang, S., Ye, Y., et al. (2024). "ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs." ICLR 2024. https://arxiv.org/abs/2307.16789

Conversational Decomposition & Context Engineering

27. Google Research. (2025). "Learning to Clarify: Multi-turn Conversations with Action-Based Contrastive Self-Training (ACT)." https://research.google/blog/learning-to-clarify-multi-turn-conversations-with-action-based-contrastive-self-training/

28. "First Ask Then Answer: A Framework Design for AI Dialogue Based on Proactive Clarification." (2025). https://arxiv.org/pdf/2508.08308

29. "A Tri-Agent Framework for Evaluating and Aligning Question Clarification." KDD 2025 Workshop. https://kdd-eval-workshop.github.io/genai-evaluation-kdd2025/

30. "ClarQ4LLM: A Benchmark for Models Clarifying and Requesting Information." IEEE 2025. https://ieeexplore.ieee.org/document/11372194

31. Anthropic. (2025). "Effective Context Engineering for AI Agents." https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents

Survey Papers

32. Huang, X., et al. (2024). "Understanding the Planning of LLM Agents: A Survey." https://arxiv.org/abs/2402.02716

33. Luo, J., et al. (2025). "Large Language Model Agent: A Survey on Methodology, Applications, and Challenges." https://arxiv.org/abs/2503.21460

34. Schulhoff, S., et al. (2024). "The Prompt Report: A Systematic Survey of Prompt Engineering Techniques." https://arxiv.org/abs/2406.06608

35. Weng, L. (2023). "LLM Powered Autonomous Agents." https://lilianweng.github.io/posts/2023-06-23-agent/

This survey was conducted as part of the IAIP Polyphonic Discussion research protocol. It covers the technical state-of-the-art in prompt decomposition engines as of April 2026. Philosophical implications and linguistic theoretical analysis are addressed by companion survey agents.