Một AI agent không phải là "ChatGPT nhưng mạnh hơn" — đó là một hệ thống có thể tự lên kế hoạch, gọi công cụ, quan sát kết quả, và lặp lại cho đến khi xong việc, gần như không cần bạn ngồi cầm tay chỉ việc từng bước.
LLM Thực Chất Là Gì?
Trước khi nói về agent, ta phải hiểu rõ nền tảng bên dưới: Large Language Model (LLM). Về bản chất, một LLM là một mô hình dự đoán token tiếp theo. Nó nhận vào một chuỗi văn bản (gọi là context — ngữ cảnh), và với mỗi bước, nó tính xác suất cho token kế tiếp dựa trên toàn bộ những gì đã có trong context đó. Nó không "hiểu" code theo nghĩa một compiler hiểu cú pháp, và nó cũng không có bộ nhớ giữa các lần gọi — mỗi request là một lần "khởi động lại" hoàn toàn, chỉ có context window (cửa sổ ngữ cảnh) là thứ giữ lại thông tin.
Điều này rất quan trọng với kỹ sư phần mềm, vì nó giải thích tại sao LLM có thể viết code rất tốt ở một số việc (pattern quen thuộc, boilerplate, refactor theo mẫu có sẵn) nhưng lại "ảo giác" (hallucination) ở những việc đòi hỏi kiến thức chính xác về codebase cụ thể của bạn — ví dụ tên hàm nội bộ, cấu trúc database, hay quy ước đặt tên riêng của team. LLM không tự động "biết" repo của bạn; nó chỉ biết những gì bạn đưa vào context, cộng với những gì nó học được từ dữ liệu huấn luyện (training data) — vốn đã đóng băng tại một thời điểm nhất định (knowledge cutoff).
Một điểm nữa cần nắm: LLM hiện đại (GPT, Claude, Gemini...) được huấn luyện qua nhiều giai đoạn — pretraining trên khối lượng văn bản khổng lồ, rồi fine-tuning và reinforcement learning để mô hình biết tuân theo instruction, biết "cư xử" như một trợ lý hữu ích, và quan trọng nhất với chúng ta: biết khi nào nên gọi một tool thay vì tự bịa ra câu trả lời.
Mẹo: Khi debug một câu trả lời "ảo giác" của LLM, đừng nghĩ là mô hình "ngu" — hãy tự hỏi: nó có đủ thông tin trong context để trả lời đúng không? 90% các ca hallucination trong công việc coding thực tế là do thiếu context, không phải do mô hình yếu.
"Tool Use" Nghĩa Là Gì Trong Thực Tế?
Tool use (gọi công cụ) là khả năng LLM tạm dừng việc sinh văn bản thuần túy, phát ra một lời gọi hàm có cấu trúc (structured function call) — ví dụ read_file(path="src/api/users.ts") hay run_tests(pattern="auth.*") — rồi nhận kết quả trả về và tiếp tục suy luận dựa trên kết quả đó. Đây chính là ranh giới phân biệt một "chatbot biết viết code" với một "coding agent" thực thụ.
Về mặt kỹ thuật, tool use hoạt động như sau:
1. Bạn (hoặc hệ thống agent) định nghĩa một tập hợp tool với tên, mô tả, và schema tham số (thường là JSON Schema).
2. LLM nhận danh sách tool này trong system prompt hoặc qua một API riêng (tool definitions).
3. Khi mô hình quyết định cần dùng tool, nó không trả lời bằng văn bản tự do mà trả về một object có cấu trúc, ví dụ: {"tool": "run_shell", "input": {"command": "npm test"}}.
4. Runtime bên ngoài (agent harness — như Claude Code, Cursor, hay một agent bạn tự viết) thực thi lệnh đó thật sự trên máy, rồi đưa kết quả (stdout, stderr, exit code) trở lại vào context.
5. LLM đọc kết quả và quyết định bước tiếp theo: gọi tool khác, sửa code, hay báo cáo hoàn thành.
Điều đáng chú ý là bản thân LLM không thực thi bất cứ điều gì — nó chỉ "yêu cầu". Tool thực sự chạy trong process runtime của agent (Claude Code, IDE plugin, hay script Python bạn viết). Đây là lý do vì sao permission model (mô hình cấp quyền) — quyết định tool nào được phép chạy tự động, tool nào cần con người xác nhận — là một phần cốt lõi của bất kỳ hệ thống agentic nào, chứ không phải tính năng phụ.
Ví dụ cụ thể một prompt kích hoạt tool use trong Claude Code:
Tìm tất cả chỗ gọi API `/v1/payments` trong repo, kiểm tra xem có chỗ nào
thiếu xử lý lỗi timeout không, và liệt kê file + số dòng cần sửa.
Với prompt này, agent sẽ tự động gọi tool tìm kiếm (grep/glob), tool đọc file, có thể cả tool chạy test — hoàn toàn không cần bạn chỉ định "hãy dùng grep" hay "hãy đọc file X".
Mẹo: Khi viết prompt cho agent, đừng mô tả cách làm (dùng lệnh gì) — hãy mô tả kết quả bạn muốn. Agent tốt sẽ tự chọn tool phù hợp; việc bạn ép nó dùng đúng một cách làm thường khiến nó bỏ lỡ cách hiệu quả hơn.
Autonomous Loop Là Gì?
Autonomous loop (vòng lặp tự động) là cơ chế cho phép agent lặp lại chu trình "suy nghĩ → hành động → quan sát" (think → act → observe) nhiều lần liên tiếp mà không cần con người can thiệp giữa mỗi bước. Đây chính là thứ biến một "trợ lý trả lời một câu hỏi" thành một "agent hoàn thành một tác vụ nhiều bước".
Cấu trúc điển hình của một vòng lặp agentic:
- Nhận goal (mục tiêu) — ví dụ: "Sửa bug khiến user không đăng xuất được trên Safari".
- Lên kế hoạch (plan) — agent tự chia nhỏ vấn đề: cần tìm code xử lý logout, cần hiểu vì sao Safari khác Chrome, có thể liên quan cookie SameSite.
- Hành động (act) — gọi tool: đọc file, tìm kiếm trong codebase, chạy test hiện có.
- Quan sát (observe) — đọc kết quả trả về: test fail ở đâu, log báo lỗi gì.
- Đánh giá lại (reflect) — so sánh kết quả với mục tiêu: đã xong chưa, hay cần lặp lại bước 2-4.
- Kết thúc hoặc tiếp tục — nếu goal đã đạt (test pass, build xanh), agent dừng và báo cáo; nếu chưa, nó tự động lặp lại vòng lặp.
Vòng lặp này có thể kéo dài từ vài giây (sửa một dòng code) đến hàng chục phút (refactor một module lớn, chạy hàng chục lượt test-sửa-test). Điều làm nó "autonomous" (tự động/tự chủ) là: giữa bước 1 và bước cuối, con người không cần ngồi gõ lệnh từng bước — agent tự quyết định bước tiếp theo dựa trên kết quả quan sát được, không theo một kịch bản cứng được lập trình sẵn.
Cần phân biệt rõ: autonomous loop khác với một pipeline CI/CD tự động chạy theo thứ tự cố định. CI/CD chạy đúng các bước đã định nghĩa trước (deterministic — tất định); autonomous loop của agent là "reasoning (suy luận) theo thời gian thực" — bước tiếp theo phụ thuộc vào kết quả bước trước, và agent có thể chọn những đường đi khác nhau cho cùng một mục tiêu tùy vào những gì nó quan sát được.
Mẹo: Khi mới làm quen với agentic loop, hãy chủ động giới hạn số vòng lặp tối đa (ví dụ Claude Code có thể dừng lại xin xác nhận sau N bước) — điều này giúp bạn quan sát và học cách agent ra quyết định, thay vì để nó chạy "mù" từ đầu đến cuối.
Vì Sao Điều Này Thay Đổi Công Việc Kỹ Sư Hằng Ngày
Sự kết hợp giữa LLM + tool use + autonomous loop tạo ra một thay đổi chất chứ không chỉ lượng trong cách kỹ sư phần mềm làm việc. Trước đây, AI hỗ trợ coding dừng ở mức "gợi ý dòng tiếp theo" (autocomplete) hoặc "trả lời câu hỏi trong chat". Giờ đây, một agent có thể tự đọc toàn bộ codebase liên quan, tự viết code, tự chạy test, tự đọc log lỗi, tự sửa lại — và chỉ quay lại hỏi bạn khi cần quyết định mang tính chiến lược hoặc khi gặp việc rủi ro cao (như xóa dữ liệu, deploy production).
Hệ quả trực tiếp lên quy trình làm việc:
- Đơn vị công việc thay đổi. Trước đây bạn giao việc cho chính mình theo dòng code; giờ bạn giao việc cho agent theo "outcome" (kết quả mong muốn) — một tính năng, một bug fix, một refactor hoàn chỉnh.
- Vai trò kỹ sư dịch chuyển từ "người viết" sang "người review và định hướng". Bạn dành nhiều thời gian hơn cho việc đặc tả rõ ràng (specification), review diff, và ra quyết định kiến trúc — ít thời gian hơn cho việc gõ từng dòng code thủ công.
- Chất lượng đặc tả (spec) trở thành kỹ năng cốt lõi mới. Vì agent hành động dựa trên context bạn cung cấp, một yêu cầu mơ hồ sẽ dẫn đến một vòng lặp agentic đi sai hướng — lãng phí thời gian hơn là tiết kiệm.
- Rủi ro cũng thay đổi hình dạng. Thay vì rủi ro "lập trình viên gõ sai một dòng", giờ là rủi ro "agent tự tin thực hiện sai hướng trên diện rộng" — một agent có thể sửa 20 file theo một hướng hiểu sai chỉ trong vài phút.
Đây là lý do vì sao suốt khóa học này, chúng ta sẽ liên tục quay lại chủ đề: agentic engineering không phải là "dùng AI để gõ code nhanh hơn" — nó là một cách tổ chức lại toàn bộ quy trình phát triển phần mềm xung quanh việc chỉ đạo và giám sát các hệ thống tự động.
Mẹo: Hãy tự hỏi với mỗi task bạn định giao cho agent: "Nếu agent này hiểu sai một chi tiết, hậu quả tệ đến mức nào?" — câu trả lời quyết định bạn nên giám sát chặt hay có thể để nó chạy tự do.
Thực Hành: Khám Phá Agentic Loop Trên Chính Môi Trường Của Bạn
Phần này giúp bạn nhìn thấy vòng lặp agentic diễn ra thay vì chỉ đọc lý thuyết. Nếu chưa cài Claude Code, hãy cài trước (chi tiết ở bài 5), sau đó thực hiện các bước sau trên một repo thật (hoặc repo test) của bạn:
Bước 1 — Quan sát bước lập kế hoạch. Mở Claude Code trong repo của bạn và gõ:
Repo này có cấu trúc như thế nào? Đừng đọc toàn bộ code, chỉ liệt kê
các thư mục chính và đoán vai trò của từng thư mục dựa trên tên file.
Quan sát: agent sẽ gọi tool liệt kê thư mục (list/glob) trước, chưa vội đọc nội dung file — đây chính là bước "lên kế hoạch" trước khi hành động sâu hơn.
Bước 2 — Kích hoạt một vòng lặp nhiều bước thật sự. Chọn một bug nhỏ có thật (hoặc tạo một bug giả) và ra lệnh:
Có một bug: hàm calculateDiscount() trả về giá âm khi số lượng = 0.
Hãy tìm nguyên nhân, viết test case tái hiện bug, sửa code, và chạy
lại toàn bộ test suite liên quan để xác nhận đã fix mà không phá vỡ
chức năng khác.
Quan sát kỹ thứ tự tool được gọi: tìm kiếm hàm → đọc file chứa hàm → đọc file test hiện có → viết test mới → sửa code → chạy test → đọc kết quả test → (nếu fail) sửa lại → chạy lại. Đây chính là autonomous loop bạn vừa học ở phần trên, đang diễn ra trước mắt bạn.
Bước 3 — Thử giới hạn vòng lặp để hiểu ranh giới tự chủ. Yêu cầu agent dừng lại xin xác nhận trước khi chạy lệnh có thể thay đổi dữ liệu:
Trước khi chạy bất kỳ migration nào hoặc lệnh có thể thay đổi
database, hãy dừng lại và hỏi tôi xác nhận.
Đây là cách thực hành đầu tiên về permission model — chủ đề sẽ được đào sâu ở các module sau (đặc biệt module về bảo mật).
Bước 4 — Ghi chép lại. Viết ra 3 điều bạn quan sát được về cách agent ra quyết định giữa các bước — bạn sẽ dùng lại quan sát này khi học về context engineering ở Module 2.
Mẹo: Lần đầu quan sát agentic loop, hãy bật chế độ hiển thị chi tiết (verbose/log mọi tool call) nếu công cụ hỗ trợ — nhìn thấy "suy nghĩ" của agent giữa các bước tool call giúp bạn xây dựng trực giác nhanh hơn nhiều so với chỉ nhìn kết quả cuối.
Những điểm chính
- LLM là mô hình dự đoán token tiếp theo dựa trên context — nó không có bộ nhớ giữa các lần gọi và không tự động biết codebase của bạn.
- Tool use là cơ chế cho phép LLM phát ra lời gọi hàm có cấu trúc; bản thân mô hình không thực thi gì — runtime của agent mới là nơi thực thi thật.
- Autonomous loop là chu trình think → act → observe → reflect lặp lại tự động, khác biệt căn bản với pipeline tất định như CI/CD.
- Sự kết hợp LLM + tool use + autonomous loop chuyển đơn vị công việc của kỹ sư từ "dòng code" sang "outcome", và chuyển vai trò kỹ sư từ người viết sang người chỉ đạo/review.
- Kỹ năng đặc tả rõ ràng (spec) và đánh giá rủi ro trước khi giao việc cho agent là hai kỹ năng nền tảng sẽ được đào sâu xuyên suốt khóa học.