From Single LLM to Multi‑Agent: How Context Engineering Drives the Next AI Architecture

Background

Industry leaders have recently debated the merits of context engineering versus multi‑agent systems. Cognition opposes multi‑agent approaches, emphasizing the immaturity of large language models (LLMs) for long‑context and proactive communication, and warns that forcing multi‑agent architectures can fragment context and dilute reliability. Anthropic explores parallel advantages but still relies on strong context engineering to share state and avoid loss of control. LangChain adopts a pragmatic stance, recommending flexible architectures that choose agents for read‑heavy tasks while keeping write‑heavy tasks in a single‑agent setup, and introduces tools like LangGraph for fine‑grained orchestration.

Core Perspectives

Cognition / Devin : Single‑agent + context engineering; simple, stable, controllable but weak parallelism and low efficiency on large tasks.

Anthropic : Multi‑agent orchestration‑worker model; strong parallel processing for information retrieval, but requires shared context to prevent fragmentation.

LangChain : Flexible composition; context engineering is essential, multi‑agent excels at "read" tasks, single‑agent preferred for "write" tasks, with LangGraph enabling hybrid designs.

Open Deep Research Architecture Evolution

The project’s evolution illustrates three distinct phases:

Phase 1 – Simple (Monolithic) Architecture

用户查询 → 单个LLM → 工具调用循环 → 生成报告

Characteristics: centralized control flow, tightly coupled components, shared memory, all logic in one reasoning engine. Problems encountered include context explosion, low efficiency due to serial processing, unstable quality, and limited depth because of token constraints.

Phase 2 – Pipeline Architecture

需求分析 → 信息收集 → 数据分析 → 报告生成

Improvements: clear responsibility separation, standardized interfaces, reusable components. New challenges remain: still serial, limited parallelism, context limits during information collection, and sub‑optimal performance on complex reasoning.

Phase 3 – Multi‑Agent Architecture (Current State)

监督者代理 → 多个专家代理并行工作 → 结果整合

Key breakthroughs: isolated context windows for each expert, parallel execution, specialized domain focus, and intelligent coordination by a supervisor that dynamically allocates tasks based on complexity.

Design Details

Phase 1 – Scope defines the task stage, compresses long dialogues into a structured brief, and applies the "Write Context" strategy to turn conversations into research briefs.

用户："切尔西区排名前十的餐厅有哪些？"
系统："你是说在曼哈顿还是伦敦？"
用户："曼哈顿"
系统："明白了，我来为您生成详细的餐厅简报..."

Core context‑engineering operations:

Write Context : Save lengthy dialogues as structured briefs.

Compress Context : Remove redundant tokens, focus on core needs.

Select Context : Provide a clear "north star" for downstream research.

Phase 2 – Research isolates each sub‑task in its own context window, allowing parallel agents to research independently without contaminating each other's state.

class ResearchSupervisor:
    def delegate_research(self, brief):
        subtopics = self.analyze_parallelization_needs(brief)
        if len(subtopics) > 1:
            sub_agents = [ResearchAgent(topic=topic, isolated_context=True) for topic, focus in subtopics]
            results = self.parallel_execute(sub_agents)
        else:
            results = self.single_thread_research(brief)
        return self.evaluate_completeness(results, brief)

Sub‑agents follow a three‑step loop: clarify requirements, collect information, analyze results, and finally generate a concise report, all while keeping their context isolated.

When to Use Multi‑Agent Systems

Tasks with highly independent sub‑tasks (e.g., comparing AI safety approaches of OpenAI, Anthropic, and DeepMind).

Scenarios requiring different research depths, where the supervisor can select an appropriate parallelism level.

Unsuitable scenarios include tightly coupled tasks that need sequential reasoning or simple single‑turn queries where a multi‑agent setup would be overkill.

Best Practices & Pitfalls

Clear Boundaries : Each agent should have a well‑defined responsibility and operate on an isolated context.

Intelligent Supervisor : Handles task decomposition, routing, parallel/serial scheduling, quality and budget control, and error recovery.

Context‑First Principle : Keep research briefs concise, compress agent outputs, and avoid token waste.

Quality Control : Verify consistency across sub‑findings and trigger re‑research if standards are not met.

Common mistakes such as letting multiple agents write separate report sections lead to incoherent style and logic; the correct approach is to let agents only research and have a single writer synthesize the final document.

Future Directions

Adaptive agent pools that scale based on workload, domain‑specialist factories for creating agents tailored to specific fields, and smarter coordination algorithms that minimize inter‑agent dependencies while maximizing parallel efficiency.

class AdaptiveAgentPool:
    def auto_scale_agents(self, workload):
        optimal_agents = self.predict_optimal_count(workload)
        if optimal_agents > self.current_agents:
            self.spawn_additional_agents(optimal_agents - self.current_agents)
        elif optimal_agents < self.current_agents:
            self.retire_excess_agents(self.current_agents - optimal_agents)

Conclusion

The progression from monolithic LLMs to pipeline designs and finally to multi‑agent architectures demonstrates a clear path for managing complexity in AI systems. Context engineering is the theoretical foundation that enables token‑efficient, scalable, and reliable multi‑agent solutions.