Agentic Pattern – Cách các AI Agent thực sự suy nghĩ

Phần 1 trong 3 của chuỗi bài “Bí thuật Claude Code”

Bạn có bao giờ tự hỏi tại sao một số trợ lý AI có thể giải quyết các vấn đề phức tạp—như debug một lỗi production hay tái cấu trúc một codebase lớn—trong khi số khác lại “đầu hàng” hoặc đưa ra những đoạn code ảo giác chỉ sau một câu trả lời?

Sự khác biệt không hẳn nằm ở việc mô hình nào “thông minh” hơn (dù IQ của mô hình chắc chắn có vai trò). Bí mật thực sự nằm ở cấu trúc vận hành (architecture) bao quanh mô hình đó. Đó chính là sự khác biệt giữa việc bắn một mũi tên trong bóng tối và việc bật đèn lên, ngắm bắn, rồi điều chỉnh cho đến khi trúng đích.

Trong bài viết đầu tiên này, chúng ta sẽ đi sâu vào Vòng lặp Agentic (Agentic Loop)—nhịp tim của mọi hệ thống AI tự chủ hiện đại.

Chatbot vs. Agent: Sự khác biệt cốt lõi

Hãy bắt đầu bằng một sự phân biệt quan trọng mà nhiều người vẫn nhầm lẫn: Chatbot và Agent.

Mô hình Chatbot: “Chiếc máy bán hàng tự động”

Hầu hết các tương tác của chúng ta với LLM (Large Language Moldels) như ChatGPT (phiên bản miễn phí) hay Claude (giao diện web cơ bản) đều hoạt động theo mô hình “Zero-shot” hoặc “One-shot”:

Input: Bạn đưa vào một câu hỏi (“Hãy viết hàm tính Fibonacci”).
Processing: Mô hình dự đoán các token tiếp theo dựa trên xác suất.
Output: Bạn nhận được câu trả lời.

Quy trình này tuyến tính và không có sự phản hồi. Nó giống như một chiếc máy bán hàng tự động: bạn bỏ tiền vào, chọn món, và món hàng rơi ra. Nếu món hàng bị kẹt? Chiếc máy không biết. Nếu bạn chọn nhầm? Chiếc máy cũng không quan tâm. Nó chỉ thực hiện một lần duy nhất.

Mô hình Agent: “Người đầu bếp tận tụy”

Ngược lại, một AI Agent hoạt động giống như một người đầu bếp đang nấu một món súp phức tạp.

Người đầu bếp không chỉ ném tất cả nguyên liệu vào nồi và dọn ra ngay (như Chatbot). Họ làm việc theo quy trình:

Nếm thử (Quan sát trạng thái hiện tại).
Suy nghĩ: “Hơi nhạt, cần thêm muối”.
Hành động: Thêm một thìa muối.
Nếm lại: “Vẫn chưa ổn, cần thêm chút tiêu”.
Hành động: Thêm tiêu.
Quyết định: “Tuyệt vời, đã xong”.

Sự khác biệt ở đây là vòng lặp phản hồi (feedback loop). Agent không chỉ đưa ra câu trả lời; nó làm việc với vấn đề cho đến khi đạt được kết quả mong muốn.

Giải phẫu Vòng lặp TAOD

Tại trung tâm của bất kỳ Agent nào (dù là AutoGPT, BabyAGI hay Claude Code), chúng ta đều tìm thấy một chu trình lặp đi lặp lại gồm 4 bước, mà tôi gọi là vòng lặp TAOD:

1. Think (Suy nghĩ)

Đây là bước mô hình LLM thực sự tỏa sáng. Thay vì nhảy ngay vào viết code, Agent sẽ tự hỏi:

Mục tiêu của người dùng là gì?
Mình đang có những thông tin gì?
Mình còn thiếu gì?
Bước nhỏ tiếp theo an toàn nhất là gì?

Trong các hệ thống tiên tiến, bước này thường sử dụng kỹ thuật “Chain-of-Thought” (Chuỗi suy nghĩ) để lập kế hoạch chi tiết trước khi làm bất cứ điều gì.

2. Act (Hành động)

Sau khi đã có kế hoạch, Agent chọn một Công cụ (Tool) để thực thi. Công cụ có thể là bất cứ thứ gì:

Đọc nội dung một file (read_file).
Chạy một lệnh terminal (run_command).
Tìm kiếm trên Google (web_search).
Gửi một tin nhắn Slack.

Điểm quan trọng: Agent không trực tiếp thay đổi thế giới vật lý; nó gọi hàm (function calling) để phần mềm trung gian thực hiện việc đó.

3. Observe (Quan sát)

Sau khi hành động được thực hiện, Agent cần xem xét kết quả.

Nếu đọc file: Nội dung file là gì? (Code, văn bản, hay file rỗng?)
Nếu chạy lệnh: Terminal trả về Success hay Error: library not found?

Bước này cực kỳ quan trọng vì nó cung cấp Sự thật (Ground Truth). Chatbot thường “ảo giác” (hallucinate) vì nó không thể kiểm chứng thực tế. Agent “nhìn” thấy thực tế thông qua bước Observe này, giúp giảm thiểu ảo giác xuống mức thấp nhất.

4. Decide (Quyết định)

Với thông tin mới từ bước Observe, Agent quay lại đánh giá:

Kết quả có giống như mình mong đợi không?
Nếu có lỗi, mình nên sửa như thế nào?
Mình đã hoàn thành nhiệm vụ chưa, hay cần lặp lại vòng lặp?

Nếu chưa xong, Agent quay lại bước Think và vòng lặp tiếp tục.

Ví dụ thực tế: Debugging một lỗi bí ẩn

Hãy xem vòng lặp này hoạt động như thế nào trong một kịch bản thực tế: Bạn nhờ Agent sửa lỗi “Server không khởi động được”.

Vòng lặp 1:

Think: Người dùng báo lỗi server. Mình chưa biết lỗi gì. Cần kiểm tra log.
Act: read_file("server.log")
Observe: File log chứa dòng Error: Port 8080 is already in use.
Decide: À, xung đột cổng. Mình cần tìm tiến trình đang chiếm cổng này.

Vòng lặp 2:

Think: Để tìm tiến trình, mình sẽ dùng lệnh lsof hoặc netstat.
Act: run_command("lsof -i :8080")
Observe: Terminal trả về: COMMAND PID: node 12345.
Decide: Đã tìm thấy thủ phạm là PID 12345. Mình cần tắt nó đi và khởi động lại server của chúng ta.

Vòng lặp 3:

Think: Kill tiến trình cũ và chạy lại server.
Act: run_command("kill -9 12345 && npm start")
Observe: Terminal in ra: Server started on port 8080.
Decide: Thành công! Nhiệm vụ hoàn thành.

Bạn thấy đấy, nếu là một Chatbot one-shot, nó có thể chỉ khuyên bạn: “Hãy thử kiểm tra xem cổng có bị chiếm không.” Nhưng Agent đã tự mình thực hiện việc kiểm tra, chẩn đoán và khắc phục.

Tại sao Vòng lặp lại đánh bại One-Shots?

1. Khả năng tự sửa lỗi (Self-Correction)

Trong thế giới code, mọi thứ hiếm khi diễn ra đúng kế hoạch ngay lần đầu.

Bạn import sai thư viện.
Lệnh syntax bị lỗi.
File không tồn tại.

Với one-shot, một lỗi nhỏ dẫn đến thất bại toàn tập. Với vòng lặp agentic, lỗi chỉ là một dữ liệu mới để quan sát. Agent nhìn thấy lỗi, nói “Ồ, mình quên cài package này”, và tự động chạy npm install ở vòng lặp tiếp theo. Đây là khả năng phục hồi (resilience).

2. Xử lý sự mơ hồ (Ambiguity)

Người dùng thường đưa ra yêu cầu rất mơ hồ: “Làm cho cái nút này đẹp hơn.” Agent có thể thử sửa CSS (Act), chụp ảnh màn hình hoặc tự đánh giá (Observe), thấy chưa ổn (Decide), và thử lại màu khác (Loop). Nó có thể khám phá không gian giải pháp thay vì phải đoán đúng ngay lập tức.

3. Chia để trị (Decomposition)

Các nhiệm vụ lớn (như “Xây dựng một website”) là quá sức với một lần suy luận (context window) của LLM. Vòng lặp cho phép Agent chia nhỏ vấn đề:

Tạo khung dự án.
Viết file HTML.
Viết file CSS.
Viết JS. Mỗi bước là một hoặc nhiều vòng lặp, giúp quản lý độ phức tạp hiệu quả hơn.

Thách thức: Biết khi nào nên dừng lại

Mặc dù mạnh mẽ, vòng lặp Agentic cũng đi kèm rủi ro lớn nhất: Vòng lặp vô tận (Infinite Loops).

Hãy tưởng tượng một Agent cố gắng sửa lỗi nhưng bản vá của nó lại gây ra một lỗi mới, và lỗi mới lại dẫn về lỗi cũ. Agent có thể bị kẹt trong việc sửa đi sửa lại mãi mãi, tiêu tốn hàng triệu token và tiền của bạn.

Chiến lược thoát (Exit Strategies)

Để xây dựng một Agent an toàn, chúng ta cần:

Giới hạn số bước (Step Budget): Luôn đặt “Hard Limit”. Ví dụ: “Nếu sau 15 bước mà chưa xong, hãy dừng lại và hỏi người dùng.”
Phát hiện lặp lại (Loop Detection): Nếu Agent thực hiện cùng một hành động với cùng một tham số 3 lần liên tiếp, hãy buộc nó dừng lại hoặc đổi chiến thuật.
Định nghĩa “Đủ tốt” (Good Enough): Không phải lúc nào cũng cần code hoàn hảo 100%. Agent cần biết đánh giá trade-off giữa chi phí và chất lượng.

Điều này có ý nghĩa gì với bạn?

Nếu bạn là một nhà phát triển đang xây dựng ứng dụng AI, hãy nhớ: Đừng cố gắng nhồi nhét tất cả trí thông minh vào Prompt (câu lệnh nhắc).

Thay vào đó, hãy đầu tư vào kiến trúc vòng lặp:

Cung cấp cho Agent những công cụ quan sát tốt (biết đọc lỗi, biết xem file).
Cho phép nó thất bại và thử lại (đừng crash chương trình khi gặp Exception).
Thiết kế cơ chế feedback rõ ràng.

Phép màu không nằm ở mô hình AI siêu việt nhất. Phép màu nằm ở sự kiên trì của vòng lặp: Thử, Sai, Sửa, và Lặp lại.

Tiếp theo: Gọi Tool & Quản lý Context →

Trong phần tiếp theo, chúng ta sẽ khám phá: Làm thế nào để một Agent biết nên dùng công cụ nào trong hàng trăm công cụ, và làm sao để nó nhớ được những gì đã làm mà không bị “tràn bộ nhớ”?