Related articles: AI Agent Design Guide | Building Blocks for AI Agents | 11 Multi-Agent Orchestration Patterns

Single and Multi-Agent Systems Based on LLMs

1. Introduction

1.1 Analysis Objective

This analysis identifies, classifies, and evaluates patterns related to LLM-based AI agents (Large Language Models) that appear promising but whose feasibility remains structurally limited with current architectures. The goal is to provide a critical, falsifiable, and non-speculative framework for evaluating the real capabilities of agentic systems.

1.2 Scope

Included:

• LLM-based agents (GPT-4, Claude, Llama, etc.)
• Single-agent and multi-agent architectures
• Orchestration, memory, tools, and supervision systems
• Observable and reproducible cases documented in the literature

Strictly excluded:

• Speculative Artificial General Intelligence (AGI)
• Marketing claims without empirical data
• Anthropomorphic descriptions of capabilities
• Untestable hypotheses

1.3 Operational Definitions

AI Agent: LLM-based system capable of perceiving a state, producing local reasoning (token generation), and triggering actions via explicit orchestration (code, API, tools).

Multi-Agent System: Set of agents coordinated by an explicit protocol. Multi-agent does not imply any emergent collective intelligence by default; any appearance of superior coordination comes from the orchestrator or communication protocol.

Scaling: Increase in model parameters, training data, or inference compute.

1.4 Summary of Key Findings

Critical Observations

1. Scaling does not solve structural limitations: Increasing model size improves factual knowledge and linguistic fluency but does not correct the absence of autonomous planning, causal reasoning, or deep logical understanding (Kambhampati et al., 2024; Valmeekam et al., 2025).
2. Multi-agent systems fail in 41-87% of cases: The MAST study (Cemri et al., 2025) identifies 14 distinct failure modes, 79% of which stem from specification and coordination problems, not technical infrastructure limitations.
3. Self-correction without external feedback is illusory: Agents cannot detect their own errors without an external deterministic verifier (compiler, test, oracle). Self-criticism increases confidence without improving accuracy (Huang et al., 2024; Stechly et al., 2024).
4. Multi-agent does not outperform single-agent on most benchmarks: Performance gains are marginal and often inferior to simple approaches like best-of-N sampling (Kapoor et al., 2024; Wang et al., 2024).
5. “Emergent capabilities” are metric artifacts: Apparent qualitative jumps during scaling result from non-linear metric choices, not real cognitive phase transitions (Schaeffer et al., 2023).

Viable vs. Premature Patterns

1.5 Design Recommendations

1. Prefer closed loops: Agentic success requires an external deterministic verifier (compiler, simulator, automated test).
2. Limit scope per agent: Performant agents operate in narrow, well-defined domains, not as “generalists”.
3. Treat multi-agent as orchestration, not collective intelligence: The real “locus of decision” is the orchestrator (often Python code), not the agents themselves.
4. Assume 85-90% as reliability ceiling: For the last 10%, invest in human supervision rather than model augmentation.
5. Document hidden dependencies: Any “autonomous” system must make explicit its implicit human dependencies (prompt engineering, data selection, validation).

2. SYNTHETIC TABLE OF ANALYZED PATTERNS

Legend of Categories

2.1 Planning and Reasoning Patterns

2.2 Multi-Agent Patterns

2.3 Memory and Context Patterns

2.4 Tools and Execution Patterns

2.5 Scaling Patterns

3. DETAILED ANALYSIS OF CRITICAL PATTERNS

3.1 Pattern: Autonomous Planning

Complete Analysis Grid

Reference Publications

• Kambhampati et al. (2024) — “LLMs Can’t Plan, But Can Help Planning in LLM-Modulo Frameworks” — ICML 2024. Formally demonstrates that autoregressive LLMs cannot plan by themselves.
• Valmeekam et al. (2023) — PlanBench series. Shows that planning performance collapses with simple variable renamings.
• Stechly et al. (2024) — Analysis of backtracking failure.

3.2 Pattern: Multi-Agent Systems with Debate

Complete Analysis Grid

Reference Publications

• Liang et al. (2023) — Shows that debate only improves if the solution is already in the data.
• Du et al. (2024) — Social Contagion: the verbose agent wins over the logical agent.
• Cemri et al. (2025) — MAST Framework: 36.94% of multi-agent failures are coordination problems.
• Gandhi et al. (2024) — Theory of Mind Gap: agents fail to model other agents’ beliefs.

3.3 Pattern: Self-Correction / Self-Refinement

Complete Analysis Grid

Reference Publications

• Huang et al. (2024) — “Self-Correction Fallacy”: without external feedback, the model validates its errors.
• Madaan et al. (2023) — Self-Refine: success conditional on feedback quality.
• Shinn et al. (2023) — Reflexion: improvement only with deterministic evaluator.
• Liu et al. (2024) — Sycophancy Trap: the agent changes a good answer to please the “critic”.

3.4 Pattern: Emergent Capabilities through Scaling

Complete Analysis Grid

Reference Publications

• Schaeffer et al. (2023) — “Emergence or Metrics?”: demonstrates that apparent emergence results from metric choices.
• Zhu et al. (2025) — Emergence Mirage: observed capabilities are misinterpreted metric optimizations.
• Gudibande et al. (2024) — The Imitation Trap: distillation copies style, not logic.

3.5 Pattern: Autonomous Multi-Agent Coordination

Complete Analysis Grid

Reference Publications

• Cemri et al. (2025) — MAST: 14 failure modes identified, 36.94% related to coordination.
• Zhang et al. (2025) — Orchestrator Bottleneck: 90% of success depends on the central orchestrator.
• Nguyen et al. (2024) — Self-Organizing Fallacy: self-organization leads to chaos without script.

4. CROSS-CUTTING SYNTHESIS OF LIMITATIONS

4.1 Structural Limitations (Inherent to LLMs)

These limitations derive directly from the architecture of autoregressive language models and cannot be resolved by scaling or prompt engineering.

4.1.1 Absence of World Model

4.1.2 Reasoning as Pattern-Matching

4.1.3 Constant Time per Token

4.1.4 Reversal Curse

4.2 Systemic Limitations (Inherent to Agentic Architectures)

4.2.1 Error Cascade

4.2.2 Responsibility Dilution

4.2.3 Error Homogeneity

4.2.4 Exponential Cost

4.3 Summary Table: The Glass Ceiling of Scaling

5. LIST OF RECURRENT ILLUSIONS

This section lists patterns that are regularly presented as acquired capabilities but which, upon analysis, are illusions or overinterpretations.

5.1 Illusion: The Agent “Understands” the Task

5.2 Illusion: Multi-Agent is More Intelligent than Single-Agent

5.3 Illusion: The Agent Learns from Its Mistakes

5.4 Illusion: Debate Improves Accuracy

5.5 Illusion: Capabilities Emerge with Scaling

5.6 Illusion: The Agent is Autonomous

5.7 Illusion: RAG “Understands” Documents

5.8 Illusion: The Agent Plans

6. REALISTIC DESIGN PRINCIPLES

6.1 Principle 1: Mandatory Closed Loop

An agent can only improve its performance if an external and deterministic verifier provides usable feedback.

Implementation:

• Always couple the agent with a compiler, interpreter, automated test, or simulator.
• Feedback must be binary (success/failure) or contain structured error information.
• Never rely on the agent’s self-evaluation.

Viable examples:

• Code + Automated unit tests
• SQL + Schema validation
• Robot + Physical simulator

6.2 Principle 2: Limited and Explicit Scope

Each agent must operate in a narrow, well-defined domain where its patterns are overrepresented in training data.

Implementation:

• Explicitly define the boundaries of the action domain.
• Refuse out-of-domain tasks rather than attempting generalization.
• Use multiple specialized agents rather than one “generalist” agent.

Anti-pattern to avoid:

• “Universal agent” that does everything
• Vague prompt like “Solve this problem”

6.3 Principle 3: Explicit Orchestration

In a multi-agent system, all coordination logic must be in the orchestrator (code), not in prompts.

Implementation:

• The workflow is defined in code (Python, etc.), not in natural language.
• Transitions between states are deterministic.
• Agents are “functions” called by the orchestrator, not autonomous entities.

Corollary:

• “Multi-agent” is often a disguised workflow. Assume this reality rather than masking it.

6.4 Principle 4: Human Supervision Beyond 85%

To achieve reliability above 85-90%, invest in human supervision, not model augmentation.

Implementation:

• Define checkpoints where a human validates critical decisions.
• Provide an “escalation” mode to a human operator.
• Measure true cost (human + compute) and not just API cost.

Economic reality:

• The cost of human supervision for the last 10% is often lower than the cost of a complex architecture that fails unpredictably.

6.5 Principle 5: Documentation of Hidden Dependencies

Any system presented as “autonomous” must make explicit its implicit human dependencies.

Mandatory checklist:

• Who wrote and optimized the prompts?
• Who selects the few-shot examples?
• Who validates the results in demos?
• Which failure cases are filtered from metrics?
• What human intervention is required in production?

6.6 Principle 6: Realistic Metrics

Measure performance in real conditions, not on contaminated benchmarks.

Implementation:

• Use truly novel test data (post-training cutoff).
• Include costs (tokens, latency, human supervision) in metrics.
• Measure robustness to perturbations, not just nominal performance.

Metrics to avoid:

• Accuracy on public benchmark (contamination)
• “Success rate” without success definition
• Cherry-picked comparisons

6.7 Summary Table: What Works vs. What Doesn’t Work

7. REFERENCE BIBLIOGRAPHIC CORPUS

7.1 Key Publications (Top 20)

7.2 Detailed Source Classification

Category A: Demonstrated and Robust Capability

Category B: Conditional / Fragile Capability

Category C: Identified Structural Limitation

Category D: Documented Failure

Category E: Premature Promise / Overinterpretation

7.3 Publications <-> Patterns Mapping

7.4 Identified Evidence Gaps

The following domains lack robust empirical evidence despite frequent claims:

8. APPENDICES

8.1 Pattern Evaluation Checklist

For any presented agentic pattern, apply this checklist:

[] 1. Does the pattern remain valid if the prompt is reduced to essentials?
[] 2. Does it work without implicit human intervention?
[] 3. Does it resist noise or ambiguity in input?
[] 4. Does it hold over time (beyond a short session)?
[] 5. Does it remain valid when multiple instances of the same model interact?
[] 6. Are results reproducible with other models of the same class?
[] 7. Is the benchmark used free from contamination?
[] 8. Do metrics capture real task success?
[] 9. Is total cost (tokens, latency, supervision) viable?
[] 10. Are human dependencies explicitly documented?

VERDICT:
- 10/10 -> Demonstrated robust capability (rare)
- 7-9/10 -> Conditional capability (document conditions)
- 4-6/10 -> Fragile pattern (don't promise in production)
- 0-3/10 -> Illusion or premature promise

8.2 Technical Glossary

8.3 Complete Bibliographic References

Academic Publications

1. Kambhampati, S., Valmeekam, K., Guan, L., et al. (2024). “LLMs Can’t Plan, But Can Help Planning in LLM-Modulo Frameworks.” Proceedings of ICML 2024, 235
   .
2. Cemri, M., Pan, M. Z., Yang, S., et al. (2025). “Why Do Multi-Agent LLM Systems Fail?” arXiv
   .13657.
3. Valmeekam, K., Marquez, M., Sreedharan, S., & Kambhampati, S. (2023). “On the Planning Abilities of Large Language Models—A Critical Investigation.” NeurIPS 2023.
4. Schaeffer, R., Miranda, B., & Koyejo, S. (2023). “Are Emergent Abilities of Large Language Models a Mirage?” NeurIPS 2023.
5. Huang, J., Shao, Z., et al. (2024). “Large Language Models Cannot Self-Correct Reasoning Yet.” ICLR 2024.
6. Dziri, N., Lu, X., Sclar, M., et al. (2023). “Faith and Fate: Limits of Transformers on Compositionality.” NeurIPS 2023.
7. Madaan, A., Tandon, N., et al. (2023). “Self-Refine: Iterative Refinement with Self-Feedback.” NeurIPS 2023.
8. Shinn, N., Cassano, F., et al. (2023). “Reflexion: Language Agents with Verbal Reinforcement Learning.” NeurIPS 2023.
9. Yao, S., Zhao, J., et al. (2023). “ReAct: Synergizing Reasoning and Acting in Language Models.” ICLR 2023.
10. Park, J. S., O’Brien, J., et al. (2023). “Generative Agents: Interactive Simulacra of Human Behavior.” UIST 2023.
11. Liang, T., He, Z., et al. (2023). “Encouraging Divergent Thinking in Large Language Models through Multi-Agent Debate.” arXiv
    .19118.
12. Gandhi, K., et al. (2024). “Understanding Social Reasoning in Language Models with Language Models.” NeurIPS 2024.
13. Liu, N. F., Lin, K., et al. (2023). “Lost in the Middle: How Language Models Use Long Contexts.” TACL 2024.
14. Greshake, K., et al. (2024). “Not What You’ve Signed Up For: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection.” AISec 2023.
15. Stechly, K., Marquez, M., & Kambhampati, S. (2024). “GPT-4 Doesn’t Know It’s Wrong: An Analysis of Iterative Prompting for Reasoning Problems.” NeurIPS FM4DM Workshop.

9. CONCLUSION

This meta-analysis establishes a critical framework for evaluating the real capabilities of LLM-based AI agents. The main findings are:

1. Limitations are structural, not circumstantial: The autoregressive architecture of LLMs imposes performance ceilings that scaling alone cannot exceed.
2. Multi-agent is not a solution to single-agent limitations: Multi-agent systems inherit their components’ limitations and add their own failure modes (coordination, error cascade).
3. Autonomy is a carefully maintained illusion: “Autonomous” systems depend on optimized prompts, coded orchestrators, and implicit human supervision.
4. Real successes are in deterministic feedback domains: Code with tests, SQL with validation, robotics with simulator — closed loops work.
5. Reliability beyond 85-90% requires humans: For critical cases, human supervision remains more effective and economical than architectural augmentation.

This analysis does not aim to discourage AI agent development, but to establish realistic expectations and robust design principles. AI agents are powerful tools when used within their validity domains, with clear awareness of their limitations.

Further Reading

• AI Agent Design Guide: What Works, What Fails — Practical synthesis with decision trees and evaluation matrices
• Building an Agent: The Art of Assembling the Right Building Blocks — Languages, orchestration, models, telemetry, storage and runtime
• The 11 Multi-Agent Orchestration Patterns — Pipeline, Supervisor, Swarm, Council: practical guide with use cases
• Agent Skills: The Onboarding Manual — Structuring instructions for specialized agents

End of document