Multi-Agent Mindset: Từ "Chatbot Đơn Độc" đến "Đội Ngũ AI" tự vận hành, phản biện và tự sửa lỗi
Mình bắt đầu bài viết này bằng một câu hỏi thật lòng: Bạn đã bao giờ giao cho ChatGPT hay Claude một nhiệm vụ "khủng" bao giờ chưa? Ví dụ như "Hãy nghiên cứu thị trường Fintech Việt Nam 2026, lập kế hoạch MVP, viết code backend, tạo test cáe và soạn email pitch cho investor"- tất cả trong một prompt duy nhất?
Kết quả thường là: AI cố gắng làm tất cả, và... làm tất cả ở mức tàm tạm. Code thì lỗi, số liệu thì "tự sáng tác", kế hoạch thì chung chung. Cảm giác như thuê một nhân viên siêu giỏi nhưng giao việc của cả phòng cho một mình họ làm một ngày.
Đó chính là bài toán mà Multi-Agent System (MAS) sinh ra để giải quyết
Mục lục
- Giới hạn tử thần cuả Single Agent
- Multi-Agent System là gì?
- Kiến trúc "Công ty AI": Phân vai như thật
- Ba mô hình cộng tác phổ biến
- Công nghệ lõi: LangGraph - Vòng lặp thay vì luồng thẳng
- ReAct + Self-Reflection: AI tự biết kiểm tra
- Human-in-the-loop: Đừng để "AI" lái xe không phanh
- Kết luận
1. Giới hạn "tử thần" của Single Agent
Trước khi đi vào giải pháp, mình muốn mổ xẻ kỹ vấn đề. Bởi vì nếu không hiểu rõ tại sao single agent thất bại, chúng ta sẽ xây multi-agent chỉ vì nghe "cool" - điều này sẽ làm lãng phí tài nguyên và kinh phí.
1.1. Context Window - Căn phòng nhỏ của AI
Mỗi LLM sẽ có một "căn phòng trí nhớ" giới hạn gọi là context window. Dù GPT-4 Turbo có 128k tokens hay Gemini 1.5 Pro tự hào với 1M tokens, khi bạn nhồi quá nhiều thông tin vào, hiện tượng "lost in the middel" sẽ xảy ra.
Nghiên cứu từ đại học UC Berkeley năm 2023 - "Lost in the Middle: How Language Models Use Long Contexts" (Liu et al., 2023) - đã chứng minh: Độ chính xác của LLM giảm đáng kể khi thông tin quan trọng nằm ở giữa context, không phải đầu hoặc . Tức là, dù bạn có 1M tokens context, AI vẫn có xu hướng "quên" phần giữa.
1.2. Jack of All Trades, Master of None
Khi một agent vừa phải search web, vừa viết code, vừa tóm tắt, vừa phê bình — nó không thể làm tốt tất cả. Đây không phải quan điểm của mình, đây là kết quả thực nghiệm: Trong paper "MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework" (Hong et al., 2023 — NeurIPS), nhóm nghiên cứu từ Peking University và các cộng sự đã cho thấy: Trên benchmark HumanEval và MBPP (hai bộ test lập trình nổi tiếng), hệ thống multi-agent với vai trò chuyên biệt (PM → Architect → Engineer → QA) vượt trội hoàn toàn so với việc dùng một single agent nhận toàn bộ yêu cầu
1.3. Không có cơ chế phản biện
Đây là điểm chết người nhất. Single agent không có "người soi gương". Nó sẽ tự tin đưa ra câu trả lời ngay cả khi sai — và thường là rất tự tin. Giống như bạn tự review code của chính mình. Bạn sẽ không thấy bug. Cần một người khác nhìn vào.
2. Multi-Agent System là gì?
Multi-Agent System là một kiến trúc trong đó nhiều AI Agent độc lập cộng tác, giao tiếp và phân chia công việc để hoàn thành một mục tiêu chung. Mỗi agent có vai trò riêng, bộ
công cụ (tools) riêng và có thể có model riêng.
graph LR
subgraph Single Agent
U1[User] --> A1[One Agent]
A1 --> |"Làm tất cả mọi thứ"| R1[Kết quả... tàm tạm]
end
subgraph Multi-Agent System
U2[User] --> O[Orchestrator]
O --> AG1[Research Agent]
O --> AG2[Coder Agent]
O --> AG3[🔎 Critic Agent]
AG1 --> AG3
AG2 --> AG3
AG3 --> |Phản hồi| O
O --> R2[Kết quả chất lượng cao]
end
3. Kiến trúc "Công ty AI": Phân vai như thật
Cách dễ hiểu nhất để thiết kế MAS là hãy nghĩ đến cách một công ty vận hành. Bạn không bao giờ thuê một người vừa làm CEO, vừa làm developer, vừa làm QA, vừa làm kế toán, phải không?
graph TD
User(["Người dùng\n(Yêu cầu đầu vào)"]) --> PM
subgraph "Multi-Agent Company"
PM["Planner Agent\n(Product Manager)\n- Phân rã task\n- Lên kế hoạch\n- Phân công việc"]
RE["Researcher Agent\n- Web Search\n- Data Collection\n- Fact Checking"]
CO["Coder Agent\n- Viết code\n- Debug\n- Refactor"]
WR["Writer Agent\n- Viết nội dung\n- Tóm tắt\n- Định dạng"]
CR["Critic Agent\n(QA / Reviewer)\n- Kiểm tra lỗi logic\n- Fact checking\n- Yêu cầu sửa lại"]
MEM[("Shared Memory\n(State Store)")]
end
PM --> RE
PM --> CO
PM --> WR
RE --> MEM
CO --> MEM
WR --> MEM
MEM --> CR
CR -->|"Chưa đạt\nYêu cầu sửa"| PM
CR -->|"Đạt yêu cầu"| Output(["Kết quả cuối cùng"])
Vai trò từng agent
| Agent | Nhiệm vụ | Tools được trang bị |
|---|---|---|
| Planner | Nhận yêu cầu, phân rã thành subtasks, phân công | LLM (GPT-4/Claude) |
| Researcher | Thu thập dữ liệu, tìm kiếm sự thật | Tavily Search, Web Scraper, Wikipedia API |
| Coder | Viết, debug, test code | Python REPL, Code Interpreter, Bash |
| Writer | Viết nội dung, tóm tắt, format | LLM + Templates |
| Critic | Đánh giá chất lượng, phát hiện lỗi, yêu cầu sửa | Rubric Checker, LLM |
4. Ba mô hình cộng tác phổ biến
Không phải lúc nào cũng dùng một kiến trúc duy nhất. Tùy bài toán, hãy chọn đúng mô hình.
4.1. Sequential (Dây chuyền)
Đơn giản nhất. Kết quả của agent này là đầu vào của agent kế tiếp. Giống băng chuyền sản xuất.
graph LR
A["Researcher\nTìm dữ liệu"] -->|"Raw Data"| B["Analyst\nPhân tích"] -->|"Insights"| C["✍Writer\nViết báo cáo"] -->|"Draft"| D["🔎 Editor\nChỉnh sửa"] --> E["Final Report"]
style A fill:#4A90D9,color:#fff
style B fill:#7B68EE,color:#fff
style C fill:#48BB78,color:#fff
style D fill:#ED8936,color:#fff
style E fill:#38B2AC,color:#fff
Ưu điểm: Dễ debug, dễ hiểu luồng
Nhược điểm: Nếu một bước sai, cả chuỗi sai. Không có phản hồi ngược.
4.2. Hierarchical (Phân cấp — Recommended)
Có một Supervisor (Manager) điều phối các Worker. Đây là mô hình mình ưa thích nhất cho production.
graph TD
S["Supervisor Agent\n(Orchestrator)"]
subgraph "Worker Pool"
W1["Worker: Search"]
W2["Worker: Code"]
W3["Worker: Analyze"]
end
S -->|"Task 1: Search about X"| W1
S -->|"Task 2: Write code for Y"| W2
S -->|"Task 3: Analyze results"| W3
W1 -->|"Results"| S
W2 -->|"Results"| S
W3 -->|"Results"| S
S -->|"Tổng hợp & Quyết định"| Output["Final Output"]
Ưu điểm: Supervisor có thể tự điều chỉnh kế hoạch dựa trên kết quả trung gian.
Nhược điểm: Supervisor trở thành bottleneck.
4.3. Collaborative / Debate (Tranh biện)
Nhiều agent độc lập giải cùng một vấn đề, sau đó tổng hợp. Đây là mô hình thú vị nhất về mặt khoa học.
graph TD
Task["Bài toán cần giải"] --> A1 & A2 & A3
A1["Agent A\nGiải pháp 1"]
A2["Agent B\nGiải pháp 2"]
A3["Agent C\nGiải pháp 3"]
A1 & A2 & A3 --> D["Debate Round\nCác agent phản biện nhau"]
D --> J["Judge Agent\nChọn giải pháp tốt nhất\nhoặc tổng hợp"]
J --> Final["Kết quả đồng thuận"]
Paper "Improving Factuality and Reasoning in Language Models through Multiagent Debate" (Du et al., MIT & Google Brain, 2023) cho thấy kỹ thuật debate giữa
nhiều LLM cải thiện độ chính xác lên đến 11% trên các bài toán suy luận so với single model, và giảm ảo tưởng (hallucination) đáng kể.
5. Công nghệ lõi: LangGraph — Vòng lặp thay vì luồng thẳng
Đây là phần kỹ thuật quan trọng nhất của bài. Nếu bạn chỉ đọc một phần, hãy đọc phần này.
Tại sao LangGraph thay vì LangChain?
LangChain truyền thống hoạt động theo mô hình DAG (Directed Acyclic Graph) — luồng chỉ đi một chiều, không quay đầu. Điều này ổn cho pipeline đơn giản, nhưng hoàn toàn không phù hợp
khi bạn cần agent "thử lại", "sửa lỗi" hay "lặp cho đến khi đạt chuẩn".
LangGraph giải quyết điều này bằng cách cho phép Cycles — vòng lặp thực sự trong đồ thị trạng thái.
stateDiagram-v2
[*] --> Planner: Nhận yêu cầu
Planner --> Researcher: Phân công nghiên cứu
Researcher --> Executor: Chuyển dữ liệu
Executor --> Critic: Nộp kết quả
Critic --> Executor: Chưa đạt\n(revision < max)
Critic --> [*]: Đạt chuẩn\n(APPROVED)
note right of Critic
Vòng lặp tự sửa lỗi
tối đa N lần
end note
Cài đặt môi trường
pip install langgraph langchain-openai langchain-community tavily-python
Code nền tảng: State + Nodes + Graph
# multi_agent_system.py
import os
from typing import TypedDict, List, Literal
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_community.tools.tavily_search import TavilySearchResults
from langgraph.graph import StateGraph, START, END
# ─────────────────────────────────────────────
# 1. SHARED STATE — "Bộ nhớ chung" của cả đội
# ─────────────────────────────────────────────
class AgentState(TypedDict):
task: str # Yêu cầu gốc từ người dùng
plan: List[str] # Kế hoạch do Planner tạo ra
research: str # Dữ liệu do Researcher thu thập
draft: str # Bản nháp do Executor tạo
critique: str # Phản hồi từ Critic
revision: int # Số lần đã sửa
max_revision: int # Giới hạn sửa tối đa
# ─────────────────────────────────────────────
# 2. KHỞI TẠO MODEL VÀ TOOLS
# ─────────────────────────────────────────────
llm = ChatOpenAI(model="gpt-4o", temperature=0)
search_tool = TavilySearchResults(max_results=5)
# ─────────────────────────────────────────────
# 3. CÁC NODE (Mỗi node = một Agent)
# ─────────────────────────────────────────────
def planner_node(state: AgentState) -> dict:
"""Agent Planner: Phân rã yêu cầu thành kế hoạch cụ thể."""
system_prompt = """Bạn là một Project Manager AI.
Nhận yêu cầu từ người dùng, hãy tạo ra một kế hoạch gồm 3-5 bước rõ ràng,
mỗi bước trên một dòng, bắt đầu bằng số thứ tự."""
response = llm.invoke([
SystemMessage(content=system_prompt),
HumanMessage(content=f"Yêu cầu: {state['task']}")
])
plan_steps = response.content.strip().split('\n')
print(f"\n[PLANNER] Kế hoạch:\n{response.content}")
return {"plan": plan_steps}
def researcher_node(state: AgentState) -> dict:
"""Agent Researcher: Tìm kiếm dữ liệu thực tế từ internet."""
# Tạo query từ task
query_response = llm.invoke([
SystemMessage(content="Tạo một search query ngắn gọn (tiếng Anh) để tìm thông tin cho task sau:"),
HumanMessage(content=state['task'])
])
search_query = query_response.content.strip()
print(f"\n[RESEARCHER] Searching: {search_query}")
# Thực hiện tìm kiếm
results = search_tool.invoke(search_query)
research_text = "\n\n".join([
f"Source {i+1}: {r['content'][:500]}"
for i, r in enumerate(results)
])
print(f"[RESEARCHER] Tìm được {len(results)} nguồn.")
return {"research": research_text}
def executor_node(state: AgentState) -> dict:
"""Agent Executor: Tạo ra bản nháp dựa trên kế hoạch và dữ liệu."""
plan_text = "\n".join(state['plan'])
critique_context = ""
if state.get('critique') and state['critique'] != "APPROVED":
critique_context = f"\n\nPhản hồi cần cải thiện từ lần trước:\n{state['critique']}"
system_prompt = """Bạn là một Content/Code Executor AI chuyên nghiệp.
Dựa vào kế hoạch và dữ liệu nghiên cứu, hãy tạo ra output chất lượng cao.
Nếu có phản hồi từ Critic, hãy cải thiện theo đúng yêu cầu."""
response = llm.invoke([
SystemMessage(content=system_prompt),
HumanMessage(content=f"""
Task: {state['task']}
Kế hoạch:
{plan_text}
Dữ liệu nghiên cứu:
{state.get('research', 'Không có dữ liệu')}
{critique_context}
Hãy tạo ra output hoàn chỉnh:""")
])
print(f"\n[EXECUTOR] Đã tạo draft (lần {state.get('revision', 0) + 1})")
return {
"draft": response.content,
"revision": state.get('revision', 0) + 1
}
def critic_node(state: AgentState) -> dict:
"""Agent Critic: Kiểm tra chất lượng và đưa ra phản hồi."""
system_prompt = """Bạn là một Quality Assurance AI khắt khe.
Nhiệm vụ: Đánh giá bản nháp dựa trên yêu cầu gốc.
Nếu đạt: Trả về đúng chuỗi "APPROVED"
Nếu chưa đạt: Liệt kê CỤ THỂ những điểm cần cải thiện (không dùng chữ APPROVED).
Tiêu chí đánh giá:
- Có đáp ứng đầy đủ yêu cầu không?
- Có thông tin chính xác, có dẫn chứng không?
- Có logic, mạch lạc không?
- Có đủ chi tiết không?"""
response = llm.invoke([
SystemMessage(content=system_prompt),
HumanMessage(content=f"""
Yêu cầu gốc: {state['task']}
Bản nháp cần đánh giá:
{state['draft']}""")
])
critique = response.content.strip()
print(f"\n[CRITIC] Phản hồi: {critique[:100]}...")
return {"critique": critique}
# ─────────────────────────────────────────────
# 4. HÀM ĐIỀU KIỆN — Quyết định kế tiếp
# ─────────────────────────────────────────────
def should_continue(state: AgentState) -> Literal["executor", "__end__"]:
"""Nếu Critic chưa duyệt VÀ chưa vượt giới hạn → sửa tiếp."""
if state['critique'] == "APPROVED":
print("\n[SYSTEM] Kết quả đã được phê duyệt!")
return END
if state['revision'] >= state['max_revision']:
print(f"\n[SYSTEM] Đã đạt giới hạn {state['max_revision']} lần sửa.")
return END
print(f"\n[SYSTEM] Chưa đạt, sửa lần {state['revision'] + 1}...")
return "executor"
# ─────────────────────────────────────────────
# 5. XÂY DỰNG ĐỒ THỊ (Graph Assembly)
# ─────────────────────────────────────────────
def build_agent_graph() -> StateGraph:
workflow = StateGraph(AgentState)
# Thêm các nodes
workflow.add_node("planner", planner_node)
workflow.add_node("researcher", researcher_node)
workflow.add_node("executor", executor_node)
workflow.add_node("critic", critic_node)
# Định nghĩa luồng chính
workflow.add_edge(START, "planner")
workflow.add_edge("planner", "researcher")
workflow.add_edge("researcher", "executor")
workflow.add_edge("executor", "critic")
# Vòng lặp tự sửa lỗi
workflow.add_conditional_edges(
"critic",
should_continue,
{
"executor": "executor", # Sửa lại
END: END # Kết thúc
}
)
return workflow.compile()
# ─────────────────────────────────────────────
# 6. CHẠY THỬ
# ─────────────────────────────────────────────
if __name__ == "__main__":
app = build_agent_graph()
result = app.invoke({
"task": "Viết một bài phân tích ngắn về xu hướng AI Agent năm 2026, có số liệu thực tế",
"plan": [],
"research": "",
"draft": "",
"critique": "",
"revision": 0,
"max_revision": 3
})
print("\n" + "="*60)
print("📄 KẾT QUẢ CUỐI CÙNG:")
print("="*60)
print(result['draft'])
6. ReAct + Self-Reflection: AI Biết Tự Kiểm Tra
ReAct là viết tắt của Reasoning + Acting — một pattern được giới thiệu trong paper "ReAct: Synergizing Reasoning and Acting in Language Models" (Yao et al., Princeton &
Google, 2022). Thay vì AI hành động ngay, nó suy nghĩ trước rồi mới làm.
Vòng lặp ReAct trông như thế này:
Thought: Tôi cần tìm thông tin về X
Action: search("X")
Observation: Kết quả tìm kiếm là...
Thought: Dựa vào kết quả, tôi cần làm Y
Action: code("Y")
Observation: Code chạy lỗi vì Z
Thought: Cần sửa Z bằng cách...
...
sequenceDiagram
participant U as User
participant A as ReAct Agent
participant T as Tools
U->>A: "Phân tích cổ phiếu VNM"
loop Vòng lặp Reason-Act
A->>A: Thought: Cần tìm dữ liệu giá cổ phiếu
A->>T: Action: search("VNM stock price 2026")
T->>A: Observation: Giá hiện tại là X, PE ratio Y...
A->>A: Thought: Có dữ liệu rồi, cần tính thêm chỉ số kỹ thuật
A->>T: Action: code("calculate RSI, MACD")
T->>A: Observation: RSI=65 (overbought), MACD bullish...
A->>A: Thought: Đủ dữ liệu rồi, viết phân tích
A->>A: Action: write_analysis()
end
A->>U: Báo cáo phân tích hoàn chỉnh
Thêm Self-Reflection vào hệ thống
Self-Reflection là khi một agent tự đánh giá output của mình trước khi gửi đi. Kết hợp với vòng lặp trong LangGraph, đây là cơ chế "kiểm tra kép":
# reflection_agent.py — Pattern Self-Reflection
from langchain_core.prompts import ChatPromptTemplate
REFLECTION_PROMPT = ChatPromptTemplate.from_messages([
("system", """Bạn là một expert reviewer.
Nhiệm vụ: Đánh giá bài viết và đưa ra phản hồi chi tiết để cải thiện.
Tập trung vào: độ chính xác, tính logic, sự hoàn chỉnh, và phong cách."""),
("human", "Bài viết cần review:\n\n{draft}\n\nHãy đưa ra phản hồi chi tiết:")
])
REVISION_PROMPT = ChatPromptTemplate.from_messages([
("system", """Bạn là một writer chuyên nghiệp.
Nhận bài viết gốc và phản hồi từ reviewer, hãy cải thiện bài viết."""),
("human", """Bài viết gốc:
{draft}
Phản hồi từ reviewer:
{reflection}
Hãy viết lại phiên bản cải thiện:""")
])
def reflection_node(state):
chain = REFLECTION_PROMPT | llm
reflection = chain.invoke({"draft": state["draft"]})
return {"reflection": reflection.content}
def revision_node(state):
chain = REVISION_PROMPT | llm
revised = chain.invoke({
"draft": state["draft"],
"reflection": state["reflection"]
})
return {"draft": revised.content, "revision_count": state["revision_count"] + 1}
7. Human-in-the-Loop: Đừng Để AI "Lái Xe Không Phanh"
Đây là phần mà nhiều tutorial bỏ qua, nhưng lại cực kỳ quan trọng khi đưa vào production.
Vấn đề của Fully Autonomous AI
Hãy tưởng tượng: Bạn xây một email marketing agent tự động. Nó có thể:
- Tự viết email → OK, an toàn
- Tự phân khúc khách hàng → OK, an toàn
- Tự gửi email cho 100,000 khách hàng → NGUY HIỂM
Một bug nhỏ trong prompt có thể dẫn đến hậu quả không thể thu hồi. Đó là lý do Microsoft AutoGen và LangGraph đều có tính năng Human-in-the-loop như một công dân hạng nhất.
graph TD
Start(["Bắt đầu task"]) --> Plan["Planner tạo kế hoạch"]
Plan --> Check{{"Human Checkpoint\n'Kế hoạch này OK không?'"}}
Check -->|"Approve"| Execute["Execute task"]
Check -->|"Modify"| Plan
Check -->|"Reject"| End(["Dừng lại"])
Execute --> PreAction{{"Pre-action Check\n'Sắp gửi 10k email, OK không?'"}}
PreAction -->|"Go ahead"| Action["Thực hiện action có ảnh hưởng lớn"]
PreAction -->|"Stop"| End
Action --> Done(["Hoàn thành"])
8. Kết Luận: Uncode Your Mindset
Nhìn lại hành trình của bài viết này, chúng ta đã đi từ câu hỏi đơn giản "Tại sao một AI không đủ?" đến việc xây dựng một hệ thống hoàn chỉnh với:
- Phân vai rõ ràng — Mỗi agent chuyên một việc, làm tốt việc đó
- Vòng lặp tự sửa lỗi — Hệ thống biết tự nhận ra và khắc phục điểm yếu
- Human-in-the-loop — Con người vẫn là người quyết định cuối cùng
- Production-ready — Tránh được những cạm bẫy thực tế
Nhưng quan trọng hơn cả là mindset change: Bạn không còn là người viết prompt, bạn là người thiết kế quy trình, người xây dựng tổ chức, người kiến tạo văn hóa làm việc cho một đội ngũ AI.
Câu hỏi thú vị để suy nghĩ tiếp: Khi mỗi công ty đều có đội ngũ AI của riêng mình, lợi thế cạnh tranh sẽ không còn nằm ở "công ty nào có AI tốt nhất" mà là "công ty nào thiết kế quy
trình AI khôn ngoan nhất".
Đó mới là bài toán của AI Engineer thế hệ tiếp theo.
Tài liệu tham khảo
- Liu, N.F. et al. (2023). Lost in the Middle: How Language Models Use Long Contexts. UC Berkeley.
- Park, J.S. et al. (2023). Generative Agents: Interactive Simulacra of Human Behavior. Stanford / Google Research.
- Hong, S. et al. (2023). MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework. NeurIPS 2023.
- Du, Y. et al. (2023). Improving Factuality and Reasoning in Language Models through Multiagent Debate. MIT / Google Brain.
- Yao, S. et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. Princeton / Google.
- Jimenez, C.E. et al. (2023). SWE-bench: Can Language Models Resolve Real-world GitHub Issues?. Princeton.
- Wu, Q. et al. (2023). AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. Microsoft Research.
All Rights Reserved
