Agent trong AI: LLM + tool trong vòng lặp quyết định

TL;DR: "Agent" không phải model thông minh hơn — nó là kiến trúc: cùng một LLM, thêm danh sách tool (mô tả bằng text), đặt vào một vòng lặp: model đọc trạng thái, quyết định gọi tool hay trả lời, kết quả tool nối vào context, rồi lặp lại. "Quyết định" đó vẫn chỉ là sinh đúng định dạng gọi hàm — cùng cơ chế next-token prediction. Agent vượt giới hạn một lần gọi (tra dữ liệu mới, gọi API, tính toán thật), nhưng cái giá là mỗi vòng cộng thêm token/độ trễ và nhân dồn xác suất lỗi. Bài toán một-phát-ăn-ngay (phân loại, trích xuất, tóm tắt) không cần agent — chỉ dùng khi số bước không biết trước và phụ thuộc kết quả bước trước.

Team dev một ngân hàng dựng bot nội bộ trả lời QA về trạng thái giao dịch test trên UAT. Câu hỏi đầu dễ: "Giao dịch mã TXN-88213 đang ở trạng thái gì?" — dán kết quả một lần gọi API vào prompt, hỏi model, xong. QA hỏi tiếp: "Hôm nay user U-4471 có giao dịch nào bị treo (pending) quá 10 phút không, và log lỗi ghi gì?" Câu này không trả lời được bằng cách dán sẵn một cục dữ liệu — phải để model tự tra nhiều lần.

Bài này bóc phép màu "agent": ghép từ gì, mạnh hơn một lần gọi ở đâu, và tốn thêm gì để đổi lấy sức mạnh đó.

1. Analogy — nhờ trợ lý đặt vé máy bay

Bạn gọi tổng đài hỏi: "Chuyến VN209 ngày 15/8 giá bao nhiêu?" Nhân viên tra bảng giá, đọc ngay con số — một câu hỏi, một câu trả lời.

Nếu giao việc mở hơn: "Tìm chuyến rẻ nhất tuần sau, hết chỗ phổ thông thì thử ngày kế, tìm được thì đặt luôn" — nhân viên phải tra giá ngày thứ nhất, hết chỗ thì tự quyết định tra ngày kế, so sánh các lần tra rồi mới đặt — mỗi bước phụ thuộc kết quả bước trước, và phải tự biết dừng khi nào.

2. Cơ chế: bóc phép màu "agent" ra ba mảnh

Agent không phải một loại model khác hay một "bộ não" tách riêng khỏi LLM. Nó ghép ba thứ:

1. Một LLM — vẫn đúng cơ chế cũ: dự đoán token kế tiếp khả dĩ nhất từ văn bản đứng trước.
2. Danh sách tool — mô tả bằng văn bản (tên hàm, tham số, tác dụng), đưa vào cùng prompt. Model không "biết gọi hàm" — nó chỉ học rằng khi cần dữ liệu ngoài, trả lời đúng là sinh text theo khuôn gọi hàm đó.
3. Một vòng lặp ở tầng hệ thống, ngoài model: đọc trạng thái, nhận quyết định "trả lời" hay "gọi tool X", nếu gọi tool thì hệ thống thực thi tool thật, nối kết quả vào context, rồi lặp lại.

"Quyết định" gọi tool nào không phải suy luận tách biệt — nó vẫn là next-token prediction, đúng cơ chế bài hallucination đã dạy.

function runAgent(question, tools, maxRounds):
    context <- [question]                        -- lich su: cau hoi + ket qua tool truoc do
    for round in 1..maxRounds:
        decision <- LLM.generate(context, tools)  -- van la du doan token ke tiep
        if decision is "answer":
            return decision.content
        else:
            toolName, args <- parse(decision)      -- doc dung dinh dang goi ham model sinh ra
            result <- executeReal(toolName, args)  -- goi API/DB THAT, ngoai pham vi model
            context <- context + [decision, result]
    return "STOP: vuot maxRounds, chua co cau tra loi chac chan"
// Time: O(maxRounds) lan goi model    Space: O(maxRounds) token tich luy trong context

LLM.generate là nơi duy nhất model được gọi — phần còn lại là code hệ thống. Thiếu maxRounds, một model liên tục chọn "gọi tool" có thể lặp vô thời hạn, không bao giờ sinh "answer".

3. Sức mạnh: vượt giới hạn của một lần gọi

Một lần gọi model tĩnh bị giới hạn bởi đúng những gì nằm trong prompt cộng dữ liệu huấn luyện: không tra được dữ liệu mới hoặc riêng tư, không gọi hành động thật ra ngoài (ghi log, gửi email), không tính toán chính xác trên dữ liệu lớn khi số bản ghi không biết trước.

Agent giải quyết cả ba bằng cách để model yêu cầu hệ thống làm hộ — tra API, chạy query, tính toán — rồi đọc kết quả thật để quyết định bước tiếp theo. Câu hỏi thứ hai của QA không trả lời được bằng một lần gọi tĩnh vì đúng lý do này: số giao dịch bị treo không biết trước, cần tra thêm log cho từng giao dịch tìm được.

4. Cái giá: token cộng dồn và lỗi nhân dồn

4.1 Chi phí và độ trễ tăng theo cấp bậc

Mỗi vòng, hệ thống gửi lại toàn bộ lịch sử cho model — model không nhớ giữa các lần gọi. Giả sử (số minh hoạ) mỗi vòng cộng thêm khoảng 500 token: vòng 1 gửi khoảng 500, vòng 2 khoảng 1000, vòng 3 khoảng 1500... Tổng sau 5 vòng là 500 cộng 1000 cộng 1500 cộng 2000 cộng 2500, bằng 7500 — gấp 15 lần một lần gọi đơn, không phải gấp 5. Độ trễ cộng dồn tương tự vì mỗi vòng chạy tuần tự, không song song được.

4.2 Xác suất lỗi nhân dồn

Giả sử mỗi bước có xác suất đúng 95%. Với chuỗi 5 bước phụ thuộc nhau, xác suất toàn bộ chuỗi đúng là 0,95 nhân với chính nó 5 lần, xấp xỉ 77% — không phải 95%. Nếu một bước bịa một con số, bước sau đọc nó như sự thật đã xác nhận và xây tiếp trên nền sai; không bước nào tự kiểm tra lại.

Đây là lý do giới hạn số vòng + điểm dừng an toàn (mục 2) bắt buộc: thiếu nó, agent vừa tốn chi phí tăng theo cấp bậc, vừa nhân dồn xác suất sai, vừa không tự dừng để báo "tôi không chắc".

5. Khi nào cần agent, khi nào chỉ cần một lần gọi?

Phần lớn bài toán hằng ngày là một-phát-ăn-ngay: toàn bộ thông tin cần đã nằm gọn trong một prompt.

Câu hỏi đó cần agent: số giao dịch bị treo không biết trước, nên không thể dán sẵn một cục dữ liệu đủ dùng — phải tra danh sách trước, rồi với mỗi giao dịch tìm được lại cần một lần gọi tool khác lấy log tương ứng. Ngược lại, câu hỏi đầu ("giao dịch TXN-88213 đang ở trạng thái gì?") chỉ cần một lần tra theo mã đã biết — không cần vòng lặp.

6. Pitfall tổng hợp

❌ Nhầm 1 — coi "agent thông minh hơn" nên dùng cho mọi tính năng AI: agent đánh đổi chi phí/độ trễ (mục 4) lấy khả năng xử lý số bước không biết trước (mục 3). Dùng cho bài toán phân loại chỉ cộng thêm chi phí và điểm hỏng.

✅ Áp bảng tiêu chí mục 5 trước: dữ liệu cần đã nằm gọn trong một prompt thì một lần gọi luôn rẻ hơn, ít điểm hỏng hơn.

❌ Nhầm 2 — không đặt giới hạn số vòng, tin model "tự biết dừng": model không có tín hiệu nội tại phân biệt "đã đủ dữ liệu" với "cứ tra thêm cho chắc".

✅ Luôn đặt maxRounds cứng (pseudocode mục 2) và một nhánh dừng an toàn — thà báo không chắc còn hơn lặp vô thời hạn hoặc bịa câu trả lời tự tin.

7. Liên hệ các bài khác

• Bài 01 — Nguyên tắc prompt — agent chỉ đặt thêm vòng lặp lên trên nền prompt tốt, không thay thế nó.
• Bài 02 — Fine-tune khi nào — fine-tune không giải quyết thiếu dữ liệu mới lúc chạy; đó vẫn là việc của tool/agent.
• Bài 04 — Eval & golden set — agent nhiều bước hơn đồng nghĩa nhiều điểm sai hơn; golden set đo được xu hướng đó thay vì tin demo.
• Bài 05 — Cost & latency — bài này mới nêu hướng chi phí tăng cấp bậc (mục 4.1); bài 05 tính con số cụ thể từ token thật.
• Bài 06 — Privacy và prompt injection — agent gọi tool thật mở thêm bề mặt tấn công so với một lần gọi chỉ sinh text.

8. Tóm tắt

• Agent = LLM + danh sách tool mô tả bằng text + một vòng lặp ở tầng hệ thống, không phải một loại model khác.
• "Quyết định" gọi tool hay trả lời vẫn là next-token prediction — cùng cơ chế gây hallucination.
• Agent vượt giới hạn một lần gọi: tra dữ liệu mới, gọi API thật, tính toán chính xác trên dữ liệu lớn.
• Mỗi vòng cộng thêm token/độ trễ tăng nhanh hơn tuyến tính; xác suất đúng cả chuỗi giảm theo cấp số nhân qua các bước phụ thuộc nhau.
• Vòng lặp có thể không hội tụ, nên luôn cần giới hạn số vòng + một điểm dừng an toàn.
• Chỉ dùng agent khi số bước không biết trước, phụ thuộc kết quả bước trước; bài một-phát-ăn-ngay không cần agent.

9. Tự kiểm tra

Bài tiếp theo: Eval & golden set — đo thay vì tin demo