AI Agent Roadmap: Từ Planner-Executor Đến Tree-of-Thought – Các Kiến Trúc Nâng Cao

ReAct không phải kiến trúc vạn năng. Rất nhiều team bắt đầu bằng một vòng lặp ReAct, thấy nó không đủ, rồi thêm reflection, rồi thêm Tree-of-Thought, và kết thúc với latency gấp bốn lần trong khi chất lượng không đổi. Vấn đề không nằm ở kiến trúc mà ở chỗ chọn kiến trúc theo cảm giác thay vì theo hình dạng của task.

Bài này so sánh sáu kiến trúc — ReAct, plan-execute, reflection, Tree-of-Thought, DAG workflow và multi-agent — theo ba tiêu chí: khi nào nó thực sự đáng tiền, chi phí và độ trễ của nó, và nó hỏng theo cách nào. Mục tiêu là để bạn chọn đúng cái rẻ nhất vẫn qua được eval, không phải cái nghe thông minh nhất.

Cập nhật 2026

  • LangGraph 1.2.20 (Python) và 1.7.2 (TS) đã ổn định với StateGraph, checkpointer và interrupt; đây là lựa chọn mặc định cho multi-agent có state.
  • Microsoft Agent Framework 1.25.0 là successor của AutoGen và Semantic Kernel; AutoGen dừng ở 0.7.5, đừng bắt đầu dự án mới trên đó.
  • OpenAI Agents SDK vẫn 0.x (0.24.0) nhưng có HITL, tool approvals và session backend đầy đủ.
  • Reasoning token bị tính như output trên mọi provider lớn. Mỗi bước “suy nghĩ thêm” là tiền thật, không phải miễn phí.

Năm tham số quyết định kiến trúc

Trước khi chọn tên kiến trúc, hãy trả lời năm câu:

  • Độ rộng tìm kiếm — task có nhiều đường đi hợp lý, hay chỉ có một quy trình đúng?
  • Độ sâu — cần bao nhiêu bước trước khi có kết quả kiểm chứng được?
  • Có được lập lại kế hoạch không — môi trường thay đổi giữa các bước, hay cố định?
  • Có tín hiệu kiểm chứng không — test, compiler, API trả lời, con số đúng/sai? Hay chỉ có “cảm giác đúng”?
  • Có thể song song không — các bước con độc lập, hay phụ thuộc tuần tự?

Năm câu này ánh xạ gần như trực tiếp sang kiến trúc. Nhiều đường đi + không có tín hiệu kiểm chứng = nơi ToT và reflection dễ lãng phí nhất. Quy trình cố định + phụ thuộc rõ = DAG, không phải agent.

Từ Planner-Executor đến Tree-of-Thought: sáu kiến trúc

1. ReAct — vòng lặp suy nghĩ và hành động

ReAct xen kẽ một bước suy luận với một tool call, lặp cho đến khi đủ thông tin. Nó hợp với task mà số bước chưa biết trước và mỗi tool call rẻ: tra cứu tài liệu, tìm kiếm, đọc file. Nó không hợp với task cần kế hoạch toàn cục vì mỗi bước chỉ nhìn thấy ngữ cảnh hiện tại.

Hai failure mode điển hình: lặp vô hạn (gọi cùng một tool với cùng tham số) và trôi dạt (mỗi bước làm một việc hơi khác mục tiêu). Cả hai đều chữa được bằng budget cứng: số bước tối đa, phát hiện lặp theo (tool, args), và một bước kiểm tra mục tiêu sau mỗi N bước. Không có budget thì ReAct là một cái máy đốt token có duyên.

2. Plan-Execute — lập kế hoạch trước, thực thi sau

Planner sinh một danh sách bước, executor chạy từng bước. Kiến trúc này tốt khi task dài, tool set biết trước, và các bước có phụ thuộc. Nó rẻ hơn ReAct ở chỗ planner chỉ gọi một lần, còn executor có thể chạy nhiều bước bằng code thường, không cần LLM cho mỗi bước.

Điểm chết là kế hoạch bị cũ. Nếu bước 3 phát hiện bước 1 sai giả định, executor không có quyền sửa. Hãy đặt một replan checkpoint sau mỗi bước có side effect: nếu kết quả lệch khỏi điều kiện kỳ vọng, dừng và gọi planner lần hai với trạng thái thật. Một lần replan rẻ hơn nhiều so với chạy tiếp một kế hoạch sai.

3. Reflection — một lượt tự soát

Reflection thêm một lần gọi model để kiểm tra đầu ra của chính nó, thường kèm rubric. Nó đáng tiền khi có tín hiệu kiểm chứng bên ngoài: test pass, schema hợp lệ, số liệu khớp, trích dẫn tồn tại. Khi đó reflection là bước sửa lỗi thật.

Nó không đáng tiền khi chỉ hỏi “bạn thấy câu trả lời này ổn không”. LLM-as-judge có position bias, verbosity bias và self-preference; một model tự chấm bài mình thường thiên vị bài mình. Nếu không có nguồn kiểm chứng độc lập, reflection chủ yếu làm câu trả lời dài hơn và đắt hơn.

4. Tree-of-Thought — tìm kiếm trên nhiều nhánh

ToT sinh nhiều “thought” ở mỗi nút, chấm điểm, giữ nhánh tốt, rồi mở rộng. Nó hợp với bài toán tìm kiếm thật: lập kế hoạch có nhiều ràng buộc, giải puzzle, tối ưu tổ hợp nhỏ, nơi trạng thái trung gian rẻ để mô phỏng và có tiêu chí chấm tương đối khách quan.

Nó không hợp với phần lớn task doanh nghiệp. Với branching factor b và độ sâu d, số lần gọi tối đa là b^d; b=3, d=3 đã là 40 lần gọi nếu không cắt tỉa, và mỗi lần gọi lại gửi kèm ngữ cảnh dài hơn. Chưa kể chất lượng cây phụ thuộc hoàn toàn vào chất lượng hàm chấm điểm — nếu evaluator thiên vị, bạn vừa trả tiền để đi sâu vào nhánh sai.

5. DAG workflow — đồ thị cố định

Đây là kiến trúc bị đánh giá thấp nhất và thường là kiến trúc đúng. Các bước và cạnh được khai báo trước; LLM chỉ được gọi ở những node cần phán đoán. Ví dụ: parse → validate → retrieve → classify → generate → check. Mỗi node có input/output kiểu rõ ràng, chạy được test, retry được, và chi phí biết trước.

Trong LangGraph, đây là StateGraph với node là hàm thuần và cạnh có điều kiện; checkpointer cho phép resume sau khi dừng. Điểm mạnh không phải “agentic” mà là khả năng debug: bạn nhìn thấy chính xác node nào sai. Nếu quy trình của bạn cố định 80% số lần, hãy làm DAG trước, rồi thêm một node agent cho 20% còn lại.

6. Multi-agent — chia vai

Multi-agent đáng tiền khi các vai cần tool, quyền hạn hoặc ngữ cảnh khác nhau thật sự: một agent đọc dữ liệu nhạy cảm, một agent chỉ được tạo nội dung, một agent kiểm tra. Nó cũng đáng tiền khi các phần việc chạy song song được và thời gian là ràng buộc chính.

Nó không đáng tiền khi bạn chỉ muốn “chia nhỏ cho dễ”. Mỗi lần chuyển giao là một lần nén ngữ cảnh, và mỗi lần nén là một lần mất thông tin. Triệu chứng phổ biến: hai agent làm trùng việc, agent điều phối không biết trạng thái thật, và tổng token tăng nhanh hơn chất lượng. Nếu các agent chia sẻ cùng một bộ tool và cùng quyền, gộp lại thành một agent có DAG bên trong.

So sánh thẳng

Kiến trúc Hợp với Hỏng khi
ReAct Số bước chưa biết, tool rẻ Thiếu budget, lặp, trôi mục tiêu
Plan-execute Task dài, tool set cố định Kế hoạch cũ, không replan
Reflection Có test/schema/nguồn kiểm chứng Model tự chấm mình
ToT Tìm kiếm, trạng thái rẻ, chấm khách quan Branching nổ, evaluator thiên vị
DAG workflow Quy trình cố định, cần debug Luồng thay đổi liên tục
Multi-agent Quyền/tool/ngữ cảnh khác nhau Chia vai không có lý do

Chi phí và độ trễ: tính bằng số bước, không bằng cảm giác

Mỗi bước LLM là một request mới mang theo ngữ cảnh tích luỹ. Vì vậy chi phí của một trajectory tăng nhanh hơn số bước: bước thứ 10 không chỉ trả cho output của nó mà còn trả cho toàn bộ lịch sử trước đó. Cộng thêm reasoning token bị tính như output, và bạn có lý do để ghét vòng lặp dài.

Ví dụ định lượng: một task ReAct 8 bước, mỗi bước 2.000 token vào và 300 token ra, dùng GPT-6.1 Sol ($2 vào / $10 ra mỗi 1M). Input xấp xỉ 16.000 token = $0,032; output 2.400 token = $0,024; tổng khoảng $0,056 cho một task. Cùng task đó chạy plan-execute với 2 lần gọi LLM và 8 bước code thường có thể rơi xuống dưới một cent. Chênh lệch 5–10 lần, không phải 5–10%.

Độ trễ còn tệ hơn chi phí vì p95 mới là thứ người dùng cảm nhận. Một vòng lặp 8 bước với mỗi bước 400 ms đã là 3,2 giây, và một bước chậm 2 giây đẩy p95 lên 5 giây dù trung bình vẫn đẹp. Hãy đo p50 và p95 theo từng kiến trúc, đừng chỉ đo trung bình.

Hybrid: workflow bọc agent

Cách triển khai thực tế nhất trong 2026 là không chọn một kiến trúc. Hãy dựng một DAG làm xương sống, và đặt agent vào đúng một hoặc hai node thật sự cần phán đoán.

  • Node tất định — parse input, gọi API, validate schema, ghi database. Không có LLM, có test, có retry.
  • Node agent — nơi input mơ hồ hoặc cần chọn giữa nhiều hướng. Có budget bước và budget token riêng.
  • Gate — trước mọi hành động không thể hoàn tác: approval của người, kiểm tra quyền, hoặc dry-run.
  • Fallback — nếu agent vượt budget hoặc trả về schema sai, quay về nhánh tất định.

Ví dụ phân loại ticket hỗ trợ: classify bằng một model nhỏ hoặc rule là node tất định; retrieve tài liệu là node tất định; chỉ khi ticket mơ hồ hoặc có nhiều yêu cầu trộn lẫn mới gọi agent để hỏi lại và chia việc. Phần lớn ticket không bao giờ chạm tới agent, và đó là điểm mạnh.

Đánh giá trajectory, không chỉ đáp án

Một agent có thể ra đáp án đúng nhờ may mắn sau 14 bước, trong đó có 3 lần gọi tool sai và 1 lần đọc dữ liệu ngoài quyền. Nếu bạn chỉ chấm đầu ra, trajectory đó qua. Cần chấm cả đường đi:

  • Task success — đúng/sai hoặc rubric, có ground truth.
  • Tool-call accuracy — đúng tool, đúng tham số, đúng thứ tự.
  • Trajectory score — số bước thừa, lặp, hành động không an toàn.
  • Cost per task — input + cached + output + reasoning.
  • p50/p95 latency — không chỉ trung bình.
# File: evals/trajectory.py
from dataclasses import dataclass

@dataclass
class Step:
    kind: str          # "llm" | "tool"
    name: str
    args_key: str = ""
    tokens_in: int = 0
    tokens_out: int = 0

PRICE_IN, PRICE_OUT = 2.0, 10.0  # USD / 1M, GPT-6.1 Sol

def score(steps: list[Step], allowed: set[str], max_steps: int = 12) -> dict:
    calls = [s for s in steps if s.kind == "tool"]
    unknown = [s.name for s in calls if s.name not in allowed]
    seen, dupes = set(), 0
    for s in calls:
        key = (s.name, s.args_key)
        if key in seen:
            dupes += 1
        seen.add(key)
    cost = sum(s.tokens_in for s in steps) / 1e6 * PRICE_IN
    cost += sum(s.tokens_out for s in steps) / 1e6 * PRICE_OUT
    return {
        "steps": len(steps),
        "over_budget": len(steps) > max_steps,
        "unknown_tools": unknown,
        "duplicate_calls": dupes,
        "cost_usd": round(cost, 4),
        "clean": not unknown and dupes == 0 and len(steps) <= max_steps,
    }

Hàm trên không thay thế eval chất lượng, nhưng nó bắt được ba lỗi cấu trúc rẻ nhất: vượt budget, gọi tool ngoài allowlist, và lặp. Chạy nó trên mọi trajectory trong CI trước khi chạm tới LLM-as-judge.

Cạm bẫy

  • Thêm reflection mà không có tín hiệu kiểm chứng — chi phí tăng, chất lượng không tăng, và câu trả lời dài hơn.
  • Dùng ToT cho task tuyến tính — bạn đang trả b^d lần gọi cho một bài chỉ có một đường đúng.
  • Multi-agent vì muốn “giống công ty” — mỗi lần chuyển giao làm mất ngữ cảnh; chỉ chia khi quyền hạn hoặc tool khác nhau.
  • Không có budget cứng — một vòng lặp không giới hạn là một lỗ hổng ngân sách, không phải một tính năng.
  • Chỉ chấm đầu ra — trajectory bẩn vẫn qua nếu đáp án may mắn đúng.

Checklist chọn kiến trúc

  1. Viết quy trình dưới dạng DAG trước; chỉ thay node cần phán đoán bằng agent.
  2. Đặt budget số bước, token và thời gian cho mọi vòng lặp; viết fallback tất định.
  3. Chỉ thêm reflection khi có test, schema hoặc nguồn kiểm chứng độc lập.
  4. Chỉ dùng ToT khi trạng thái trung gian rẻ và evaluator độc lập với generator.
  5. Chỉ tách multi-agent khi quyền hạn, tool set hoặc ngữ cảnh thật sự khác nhau.
  6. Đo p95 và cost per task theo từng kiến trúc trên cùng một bộ eval.

Hướng tới 2027

Các framework đang hội tụ về cùng một mô hình: graph có checkpoint, interrupt cho human-in-the-loop, và durable execution bên ngoài process. Điều đó làm DAG workflow mạnh hơn và làm multi-agent bớt hấp dẫn như một mặc định. Kiến trúc sẽ không còn là điểm bán hàng; thứ phân biệt sản phẩm là eval trajectory và khả năng dừng đúng lúc.

Đọc tiếp: ReAct và Chain-of-Thought, framework agent, kiểm thử agent, và đánh giá bằng LangSmith, Ragas và DeepEval.