AI Agent Technology Architecture Evolution 2025 (In-Depth Research Report)

When to open this wiki: when you are building Agent products, explaining to your boss "whether the Agent track is worth investing in", or writing technical proposals and looking for references. This wiki is not a "post extraction", but compiled by newtype research report-level materials, based on 8 rounds of parallel searches with Tavily+Exa, covering the period from October 2024 to January 2026.

Compared with newtype · Agent Architecture and Multi-Agent Orchestration differences between: the former is Huang Yihe's post-level judgments (2024-2026);this wiki presents a complete industry landscape as of January 2026 — technology stack + framework comparison + real deployment cases + trend forecasts. The two are complementary rather than substitutes.

1. Six Major Evolution Trends of Agents (2024-2025)

Core trend: In 2025, Agents completed the leap from "experimental toys" to "enterprise-grade infrastructure".

Evolution Dimension	2024 Status	2025 Status	Key Events
Architecture Pattern	Single ReAct loop	4 major orchestration patterns (Supervisor/P2P/Hierarchical/Event-Driven)	Major vendors rolled out multi-Agent implementations
Memory System	Within session only	Cross-session persistent memory (MemoryOS 3 layers)	MemoryOS paper (2025-06)
Tool Calling	Custom protocol for each vendor	MCP standardization	Anthropic launched MCP (2024-11)
Reasoning Framework	Single ReAct	ReAct → ToT → GoT → WoT evolution	GoT paper (2023) + commercialization of LRM (2025)
Production Deployment	Demo stage	Enterprise-grade deployment (98% adoption at Morgan Stanley)	LangGraph 1.0 / MAF release
Protocol Ecosystem	No standards	Coexistence of MCP + A2A dual protocols	A2A project entered the Linux Foundation

2. Multi-Agent Orchestration: 4 Core Patterns

The Google ADK team summarized 4 foundational multi-Agent orchestration patterns, which are widely adopted across the industry.

2.1 Supervisor

      ┌──────────┐
      │Supervisor│
      └────┬─────┘
       ┌───┼───┐
      ↓    ↓    ↓
    Agent1 Agent2 Agent3

Characteristics: Centralized decision-making, with the Supervisor routing tasks. Applicable scenarios: Tasks with clear boundaries and specialized Agent division of labor (e.g., customer service → routing to billing/technical support/refund Agents). Implementation: Natively supported by both LangGraph and CrewAI. Problems: The Supervisor becomes a bottleneck; latency accumulates under high concurrency.

2.2 P2P Swarm

Agent1 ←──→ Agent2
   ↕    ╲╱    ↕
Agent3 ←──→ Agent4

Characteristics: Agents communicate directly with each other, with no central Supervisor. Applicable scenarios: Collaborative tasks (e.g., multiple Agents co-writing a paper, each responsible for one section and conducting cross-reviews). : AutoGen:OpenAI Swarm, AutoGen. Problems: Hard to predict and debug; prone to infinite loops.

2.3 Hierarchical

        ┌─────┐
        │ CEO │
        └──┬──┘
     ┌─────┼─────┐
   ┌─VP─┐ ┌─VP─┐ ┌─VP─┐
  ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐
  Worker × N

Characteristics: Multi-layer Supervisor + Worker structure. Applicable scenarios: Large and complex tasks (e.g., Devin-style Engineering Agents with three layers: Architect / Coder / Reviewer). : LangGraph:CrewAI, Microsoft Agent Framework. Problems: Deeper hierarchy = accumulated latency; information may be lost at each layer.

2.4 Event-Driven

       ┌─────────┐
       │ Event   │
       │ Bus     │
       └────┬────┘
       ┌───┼───┐
       ↓   ↓   ↓
    Agent1 Agent2 Agent3
    (订阅 (订阅 (订阅
    EventA) EventB) EventA+C)

Characteristics: Agents subscribe to events and process them asynchronously when triggered. Applicable scenarios: Real-time systems (trading, monitoring, alerting). : Event-driven frameworks / message queues:Kafka + Agent / Temporal + Agent. Problems: Complex state management; uncontrollable event ordering.

2.5 Google ADK's 8 Foundational Orchestration Patterns

Building on the 4 patterns above, Google ADK recommends 8 practical patterns:

Sequential(Sequential Pipeline)
Parallel(Parallel Aggregation)
Loop(Loop Iteration Until Criteria Met)
Router(Content-Based Routing)
Fork-Join(Scatter-Gather)
Map-Reduce(Large Data Chunk Processing)
Reflexion(Self-Reflection and Self-Correction)
Hierarchical Plan-Execute(Planning-Execution Separation)

3. Memory Management: MemoryOS 3-Layer Architecture

One of the most critical papers in 2025: MemoryOS (arXiv:2506.06326) proposes that Agents should have a 3-layer memory system.

3.1 Three-Layer Architecture

Layer	Full Name	Human Brain Analogy	Storage Medium	Lifecycle
STM	Short-Term Memory	Working memory	RAM / context window	Current session
MTM	Mid-Term Memory	Hippocampus	Redis / relational database	Days to weeks
LPM	Long-term Personal Memory	Cerebral cortex	Vector database + KV store	Permanent

3.2 Information Flow

新信息进入 → STM
   ↓ (session 结束 / 重要性高)
重要的进入 MTM(结构化存储)
   ↓ (跨 session 验证 / 长期价值)
持久化的进入 LPM(向量化 + index)

3.3 Key Design Principles

Not all information goes into LPM — use LLMs to automatically judge importance, and only persist key facts
Forgetting is a feature — STM decays automatically, MTM is cleaned periodically, and LPM only retains user-verified content
Interpretability — the Agent can tell the user "I remember X because you said Y last time"

3.4 Vector Database Selection Comparison

Vector Database	Advantages	Applicable Scenarios
Pinecone	Managed, stable, strong filtering capabilities	Enterprise production
Weaviate	Multimodal, built-in GraphQL	Complex queries
Qdrant	Written in Rust, strong local deployment support	Private deployment
Chroma	Simple, quick to get started	Prototypes / small projects
Milvus	Large-scale (10B+ vectors)	Big data
pgvector(Postgres plugin)	Integrates with existing PG	Existing PG infrastructure

Selection Decision Tree:

Tens of millions of vectors + existing PG → pgvector
Tens of millions of vectors + new build → Pinecone (managed, hassle-free)/ Qdrant (local)
Hundreds of millions of vectors → Milvus (distributed)
Multimodal → Weaviate
Prototype → Chroma

3.5 Mem0: A Simplified Memory Framework

Mem0 (arXiv:2504.19413) is an open-source implementation of the MemoryOS concept, which rose rapidly in 2025:

Single API:mem0.add() / mem0.search() / mem0.update()
Automatically uses LLMs to extract facts, deduplicate, and merge conflicts
Plug-and-play with LangGraph / CrewAI / OpenAI / Anthropic

4. Tool Calling and MCP Standardization

In November 2024, Anthropic launched MCP (Model Context Protocol), which became the de facto standard in 2025.

4.1 Core Problems Solved by MCP

Before: Each LLM vendor had its own function calling format; every tool required N adapters for different LLMs. After MCP: Tools are implemented in only one MCP format, and all MCP-supporting LLMs can call them.N × M adapters become N + M.

4.2 MCP Ecosystem (as of January 2026)

Category	Quantity / Status
Official MCP servers	50+(GitHub, Slack, Notion, Postgres, Filesystem,...)
Community MCP servers	1000+
MCP-supporting clients	Claude Desktop, Claude Code, Cursor, Continue, Zed,...
Not supported (but with adapters)	OpenAI, Google Gemini (via mcp-bridge)

4.3 MCP vs Traditional Function Calling

Dimension	Function Calling	MCP
Protocol	Custom per vendor	Unified (JSON-RPC)
Tool Description	LLM-specific schema	Universal Tool schema
Bidirectional Communication	Unidirectional (LLM → tool)	Bidirectional (server can actively push resources)
Resources	Only supports tool calling	Tools + Resources + Prompt templates (Prompts)
Cross-Process	Cross-process calls	stdio / SSE / WebSocket

4.4 ReAct + Tool Routing

ReAct (Reasoning + Acting) is the basic tool calling loop:

while not done:
    thought = LLM.think(context)
    action = LLM.choose_tool(thought)
    observation = tool.execute(action)
    context.append(thought, action, observation)

Tool Routing(2025 optimization): When there are too many tools, first use a cheap model to select the top-5 tools from 100, then use an expensive model for reasoning:

Reduce prompt tokens (only insert 5 tool descriptions instead of 100)
Improve accuracy (the expensive model selects accurately from a small set)
Reduce costs (cheap model handles routing)

5. Reasoning Framework Evolution: ReAct → ToT → GoT → WoT

From 2022 to 2025, reasoning paradigms went through 4 generations of evolution.

5.1 ReAct(2022)

Alternating Reasoning + Acting:

Thought1 → Action1 → Observation1 → Thought2 → ...

Advantages: Simple, transparent tool calling. Disadvantages: Single-line reasoning, no backtracking.

5.2 Tree of Thoughts(2023)

Multi-branch reasoning + evaluation:

Thought_root
   ├─ Branch1 (score: 0.7)
   ├─ Branch2 (score: 0.9) ← 选这条
   └─ Branch3 (score: 0.5)
       └─ ...

Advantages: Can try multiple paths and select the optimal one. Disadvantages: High computational cost (N times more tokens).

5.3 Graph of Thoughts(2023)

Directed acyclic graph, branches can be merged:

A ─→ B ─→ D
 ╲       ╱
  C ────╯

Advantages: Complex problems can "reuse intermediate results". Disadvantages: Complex implementation, hard to debug.

5.4 Workflow of Thought(2025)

Explicit workflow definition + LLM fills in the blanks:

workflow:
  - step: gather_requirements
    agent: PM
  - step: design_architecture
    agent: Architect
    depends_on: gather_requirements
  - step: implement
    agent: Coder
    parallel: true
    branches: [frontend, backend, db]
  - step: review
    agent: Reviewer

Advantages: Predictable, monitorable, single steps can be retried. Disadvantages: Reduced flexibility (similar to Airflow but more flexible than Airflow).

5.5 Which to Use When

Scenario	Recommendation
Simple tool calling	ReAct
Math / logic problems	ToT (built into GPT-4 / Claude)
Complex planning (code generation)	GoT
Enterprise processes (approvals, SOPs)	WoT

6. Rise of Large Reasoning Models (LRM)

2024-2025 evolution from LLM to LRM (Large Reasoning Model):

OpenAI o1(2024-09)→ o3(2025-Q1)
DeepSeek R1(2025-01)
Anthropic Claude 4 Opus / Sonnet 4.6 with extended thinking
Google Gemini 2.5 Deep Think
xAI Grok 4 Heavy

Differences between LRM and LLM:

Introduces "chain of thought" as a reinforcement learning signal during training
Explicitly outputs thinking tokens (internal "scratch paper") during reasoning
Significantly improved accuracy on complex problems (math, code, planning)
But low ROI for simple problems (20x compute for 5% accuracy gain)

Impact on Agents:

Use LRM for complex Agent tasks (planning, debugging)
Use regular LLMs for simple Agent tasks (tool calling, queries)
Hybrid architecture (mixed deployment): Planner uses LRM, Executor uses regular LLM

7. 7-Layer Architecture for Production-Grade Agents

In 2025, the industry reached a consensus: production-grade Agent systems consist of 7 layers.

┌──────────────────────────────────┐
│ 7. Evaluation     (评估 / Eval)   │
├──────────────────────────────────┤
│ 6. Security       (安全 / Guardrail) │
├──────────────────────────────────┤
│ 5. Observability  (可观测性)        │
├──────────────────────────────────┤
│ 4. Orchestration  (编排)           │
├──────────────────────────────────┤
│ 3. Tool           (工具 / MCP)      │
├──────────────────────────────────┤
│ 2. Memory         (记忆 / 3 层)     │
├──────────────────────────────────┤
│ 1. Foundation     (基础模型)        │
└──────────────────────────────────┘

7.1 Foundation (Base Models)

GPT-5 / Claude 4 / Gemini 2.5 / Grok 4 / Llama 4
Selection: task complexity × cost × latency × privacy

7.2 Memory

3 layers (STM / MTM / LPM) - see Section 3

7.3 Tool

MCP server + Tool Routing - see Section 4

7.4 Orchestration

LangGraph / CrewAI / MAF / AutoGen - see Section 8

7.5 Observability

LangSmith / Langfuse / Arize / Phoenix
Key metrics: latency, Token consumption, tool success rate, Agent decision path

7.6 Security

Prompt Injection protection: input sanitization + output filtering
OWASP Top 10 for LLM
Tool calling sandbox (isolation of dangerous commands)

7.7 Evaluation

Evals-as-a-Service(Braintrust / Promptfoo / DeepEval)
Golden dataset + continuous regression testing
LLM-as-Judge (use a stronger LLM for evaluation)

VIII. Comparison of Mainstream Agent Frameworks

By the end of 2025, there are 6 mainstream Agent frameworks, each with its own positioning.

Framework	Producer	Strengths	Weaknesses	Applicable Scenarios
LangGraph	LangChain	Explicit graphs, strong state, largest ecosystem	Steep learning curve	Complex workflows / enterprise production
CrewAI	João Moura (open source)	Intuitive role division, quick to get started	Slow at medium to large scale	Small and medium projects / clearly defined roles
Microsoft Agent Framework(MAF)	Microsoft	.NET native, enterprise-grade	Small ecosystem	.NET enterprises
AutoGen	Microsoft Research	Early benchmark for multi-Agent systems	Maintenance mode(MS shifts to MAF)	Existing legacy projects
LlamaIndex	LlamaIndex Inc.	Strong RAG, document-intensive tasks	Agent is an extension	Document/knowledge management
Google ADK	Google	Vertex AI integration, 8 major patterns	Locked to GCP	Google Cloud users

8.1 Framework Selection Decision Tree

需求评估
  ├─ 单一任务(无编排) → OpenAI Function Calling 直接调
  ├─ 多步骤工作流 + state 重要 → LangGraph
  ├─ 角色分工明确 → CrewAI
  ├─ 企业 .NET → Microsoft Agent Framework
  ├─ 文档密集 → LlamaIndex + RAG
  ├─ Google Cloud → Google ADK
  └─ 复杂推理(规划) → o3/Claude + Graph-of-Thought

8.2 Common Capabilities of Frameworks (Commoditized by End of 2025)

Tool calling + MCP
Multi-Agent orchestration
Checkpointing (resume from breakpoints)
Human-in-the-loop (human-machine collaboration)
Streaming output
Token usage tracking

IX. Real-World Deployment Cases (2025)

In 2025, enterprise-level Agent deployment rolled out at scale; representative cases:

9.1 Morgan Stanley

Among the company's 16,000+ advisors 98% use AI Agents daily(Based on GPT-4)
Use cases: research report retrieval, customer email drafting, compliance checks
According to OpenAI's case study: saves advisors 30% of research time

9.2 Klarna (European buy now, pay later)

Used an OpenAI customer service Agent to replace700 customer service agents
Estimated improvement:$40M / year(2024 report)
Handles: 70% of customer service inquiries
Satisfaction: on par with human agents

9.3 BBVA (Spanish bank)

Deployed 2,900 internal Agents within 5 months
Using Microsoft Copilot Studio + self-developed orchestration
Use cases: compliance review, customer analysis, internal knowledge retrieval
ROI: Reports show 15-25% improvement in employee productivity

9.4 Rakuten (Japan)

Used Claude 4 Opus to process 12.5 million lines of code codebase
Use cases: bug fixes, refactoring, code review
According to Anthropic's case study: 4x improvement in engineering efficiency

9.5 Anthropic Internal Usage Data (2025-02 to 08)

Claude.ai monthly active users: 85 million (2025-08)
API call growth: 5x (2025-Q1 → Q3)
Internal Claude Code usage: daily use by all Anthropic employees
70% of code PRs include Claude assistance

X. 2026 Trend Forecasts

Compiled based on judgments from multiple analysts organized by newtype:

10.1 Technology Trends

Reasoning-first: LRMs further replace LLMs; reasoning quality surpasses token price in importance
Multimodal Agents: View images, listen to audio, operate UIs (GUI Agent / Computer Use)
World Models: Agents have built-in physical / spatiotemporal / causal models (Yann LeCun's approach)
Efficiency-first: Small models + tool calling > large model direct generation (DeepSeek style)
Agent interoperability: A2A protocol, cross-vendor Agent collaboration

10.2 Standards and Protocols

MCP: Becomes the de facto standard (already over 1000 servers)
A2A(Agent-to-Agent): Enters the Linux Foundation, cross-vendor collaboration protocol
AGENTS.md: "Instruction manuals" provided by websites for Agents
llms.txt: "Content indexes" provided by websites for LLMs

10.3 Regulation

EU AI Act: 2026 is the first year of enforcement; Agent deployment is subject to compliance constraints
NIST AI Risk Management Framework: US compliance standard
Enterprise-level Agent auditing: Third-party audit services emerge

10.4 Eval Ecosystem

Standardized datasets: SWE-bench, HumanEval++, MCPMark
Third-party certification services: "AI Agent compliance certification" similar to SOC2
Evals-as-a-Service platforms

XI. 10 Principles for Agent Deployment (Report Summary)

Specialization > Generalization: Multiple small Agents are better than a single large Agent
Observability from day one: No monitoring = no production
Memory is a first-class citizen: Not only able to act, but also able to remember
Tool standardization: MCP is better than custom integrations
Reasoning transparency: ReAct/GoT is better than black boxes
Recoverable state: Checkpointing is essential
Human-machine collaboration: HITL is a feature, not a bug
Cost awareness: Model downgrading + caching + batching
Security built in: Consider OWASP Top 10 from the design phase
Continuous evaluation: Evals drive iteration

XII. Production Checklist

Development Phase:

Define clear Agent roles and boundaries
Implement tool descriptions (JSON Schema / MCP)
Write unit tests (tool calling + reasoning paths)

Pre-deployment:

Configure observability (logs, tracing, metrics)
Implement security measures (Prompt Injection protection)
Prepare Eval datasets (real user scenarios)
Set cost alerts (Token limits)

Production Operation:

Monitor key metrics (latency, success rate, cost)
Collect user feedback (RLHF data)
Run Evals regularly (regression testing)
Maintain an Incident Playbook (fault response)

XIII. Connections to Existing Wiki

newtype · Agent Architecture and Multi-Agent Orchestration: newtype's post-level judgments (2024-2026). An individual perspective.
Wang Kai's Multi-Agent Browser Matrix Architecture (v1.1 Practical Guide): Wang Kai's browser Agent matrix practice (v1.1). An implementation perspective.
newtype · MCP Protocol and Ecosystem Practice: newtype's judgments and practice on MCP.
newtype · AI Tool Stack Practice and Evolution: newtype's tool stack evolution.
AI Agent Market Investment Trends 2025 (Data Report):A companion piece to this wiki, covering markets and capital.

History

2026-05-16: Phase 3 ingest created from11_AI_Agent_技术架构演进_2025.md(published 2026-01-14). Fully covers 6 major evolutions + 4 major orchestrations + 8 major patterns + 3 layers of memory + MCP standardization + 4 generations of reasoning + LRM + 7-layer architecture + 6 major frameworks + 4 major cases + 2026 trends + 10 principles + production checklist.