AI agent là gì? Giải thích cho lập trình viên (2026)

AI agent khác chatbot và workflow ở đâu? Giải thích từ góc nhìn dev: vòng lặp model, tool và phản hồi từ môi trường, agent loop TypeScript rút gọn, coding agent hiện nay và khi nào không nên dùng agent.

Bạn gõ vào Claude Code một câu: "test đăng nhập đang fail, sửa giúp". Nó chạy test, đọc stack trace, mở vài file liên quan, sửa một chỗ so sánh ngày giờ, chạy lại test cho tới khi xanh, rồi dừng lại chờ bạn xem diff. Bạn không chỉ nó bước nào cả. Thứ đang làm việc đó có tên là AI agent.

Bài này giải thích AI agent là gì từ góc nhìn dev: khác chatbot và workflow ở đâu, chạy vòng lặp nào, viết bằng code ra sao, và khi nào không nên dùng.

AI agent là gì

AI agent là hệ thống trong đó LLM tự quyết định bước tiếp theo: chọn tool, gọi tool, đọc kết quả thật từ môi trường rồi lặp lại cho tới khi xong việc, thay vì chạy theo các bước code định sẵn.

Trong bài "Building effective agents", Anthropic gọi chung nhóm này là agentic systems (hay agentic AI) và chia làm hai loại:

• Workflow: LLM và tool được điều phối theo các nhánh code định sẵn. Bạn quyết định thứ tự các bước.
• Agent: LLM tự điều hướng quá trình và tự chọn tool. Bạn giao mục tiêu, model chọn đường đi.

OpenAI định nghĩa gần giống: agent tự hoàn thành task thay bạn với mức độ độc lập cao. Chatbot đơn giản, LLM trả lời một lượt hay bộ phân loại cảm xúc thì không phải agent, vì LLM không điều khiển luồng thực thi.

Chatbot, workflow và agent khác nhau thế nào

Nhiều hệ thống được quảng cáo là "agent" thật ra là workflow (prompt chaining, routing, orchestrator-workers...), và điều đó hoàn toàn ổn.

Augmented LLM: viên gạch nền

Nền của mọi agent là augmented LLM: model được gắn thêm retrieval (tìm thông tin), tool (hành động) và memory (ghi nhớ).

Phần "tool" dựa vào function calling (tool use): bạn mô tả các hàm bằng JSON Schema, model không tự chạy hàm mà trả về yêu cầu "gọi hàm X với tham số Y", code của bạn chạy rồi gửi kết quả lại. Chuẩn MCP giúp kết nối tool mà không phải viết lại cho từng công cụ.

Vòng lặp agent: nghĩ, gọi tool, quan sát, lặp lại

Agent là augmented LLM chạy trong một vòng lặp:

1. Nghĩ: model đọc mục tiêu và toàn bộ context hiện có, quyết định làm gì tiếp.
2. Gọi tool: đọc file, grep, chạy lệnh, gọi API.
3. Quan sát: nhận kết quả thật từ môi trường, ví dụ output của test, nội dung file, mã lỗi.
4. Lặp lại: dựa trên kết quả đó, quyết định bước tiếp theo.

Mấu chốt nằm ở bước 3. Anthropic nhấn mạnh agent cần lấy "ground truth" từ môi trường ở mỗi bước: chạy test và đọc lỗi thật giúp agent tự sửa sai thay vì đoán mò. Docs Claude Code gọi ba pha của vòng lặp là gather context, take action, verify results.

Khi nào vòng lặp dừng

Một vòng lặp không có điều kiện dừng là một hoá đơn API không có giới hạn. Các điều kiện dừng thường gặp:

• Model tự báo xong: trả lời mà không gọi thêm tool nào.
• Giới hạn số bước: Anthropic nêu điều kiện dừng như số vòng lặp tối đa là cách giữ quyền kiểm soát.
• Vượt ngưỡng lỗi: OpenAI khuyên đặt giới hạn số lần thử lại, vượt ngưỡng thì chuyển cho người.
• Checkpoint của con người: agent dừng lại xin xác nhận trước hành động quan trọng.

Các thành phần của một agent

OpenAI rút gọn agent thành model, tools, instructions. Một coding agent thật có thêm vài lớp:

• Model: bộ não ra quyết định. OpenAI gợi ý prototype với model mạnh nhất để có baseline, rồi mới thử model nhỏ hơn. Model nhỏ giờ cũng gánh được nhiều việc trong agent: Claude Haiku 5.5 (ra ngày 7/10/2026) được Anthropic định vị cho phân loại, routing, trích xuất và subagent.
• Tools: tool lấy dữ liệu (đọc file, query DB), tool hành động (ghi file, gửi tin nhắn), tool điều phối (một agent khác). Anthropic khuyên thiết kế tool kỹ như thiết kế UI: mô tả rõ, có ví dụ, khó dùng sai.
• Memory và context: những gì model "nhìn thấy" ở mỗi bước. Context càng đầy thì chất lượng càng dễ giảm, xem thêm bài Context engineering là gì.
• Planning: chia task lớn thành bước nhỏ, ví dụ plan mode trong Claude Code.
• Guardrails: lớp chặn đầu vào, đầu ra và hành động nguy hiểm. OpenAI khuyên kết hợp nhiều lớp vì một lớp đơn lẻ khó đủ.
• Human-in-the-loop: bạn có thể ngắt agent bất cứ lúc nào để đổi hướng hoặc bổ sung thông tin.

Code minh hoạ: một agent loop bằng TypeScript

Cách nhanh nhất để thôi coi agent là "phép màu" là tự viết một cái. Code dưới đây dùng SDK chính thức @anthropic-ai/sdk, theo mẫu manual loop trong docs tool use của Anthropic. Đây là ví dụ rút gọn để hiểu cơ chế, chưa có sandbox hay streaming như production.

// agent-loop.ts: ví dụ rút gọn, KHÔNG dùng nguyên văn cho production
import Anthropic from "@anthropic-ai/sdk";
import { readFile } from "node:fs/promises";
import { exec } from "node:child_process";
import { promisify } from "node:util";
import path from "node:path";

const client = new Anthropic(); // đọc ANTHROPIC_API_KEY từ biến môi trường
const sh = promisify(exec);
const ROOT = process.cwd();
const MAX_STEPS = 10; // điều kiện dừng cứng

const tools: Anthropic.Tool[] = [
  {
    name: "read_file",
    description: "Đọc nội dung một file trong project. Chỉ nhận đường dẫn tương đối.",
    input_schema: {
      type: "object",
      properties: { path: { type: "string" } },
      required: ["path"],
    },
  },
  {
    name: "run_tests",
    description: "Chạy test suite của project (npm test) và trả về output.",
    input_schema: { type: "object", properties: {} },
  },
];

type ToolOutput = { content: string; is_error?: boolean };

async function executeTool(name: string, input: unknown): Promise<ToolOutput> {
  try {
    if (name === "read_file") {
      const { path: rel } = input as { path: string };
      const full = path.resolve(ROOT, rel);
      // guardrail tối thiểu: chỉ cho đọc file nằm trong thư mục project
      if (!full.startsWith(ROOT + path.sep)) {
        return { content: "Lỗi: chỉ được đọc file trong project", is_error: true };
      }
      return { content: await readFile(full, "utf8") };
    }
    if (name === "run_tests") {
      try {
        // exec với chuỗi lệnh cố định: chạy được cả Windows lẫn macOS/Linux
        const { stdout, stderr } = await sh("npm test", { timeout: 120_000, maxBuffer: 10 * 1024 * 1024 });
        return { content: `${stdout}\n${stderr}` };
      } catch (err: any) {
        // test fail vẫn là kết quả hợp lệ: đưa nguyên output cho model đọc
        if (typeof err.code === "number") return { content: `Test fail:\n${err.stdout}\n${err.stderr}` };
        throw err; // không chạy được npm, bị timeout...
      }
    }
    return { content: `Không có tool tên ${name}`, is_error: true };
  } catch (err: any) {
    // lỗi của tool (file không tồn tại, timeout...) trả về cho model, không làm sập vòng lặp
    return { content: `Lỗi: ${err.message}`, is_error: true };
  }
}

export async function runAgent(task: string) {
  const messages: Anthropic.MessageParam[] = [{ role: "user", content: task }];

  for (let step = 0; step < MAX_STEPS; step++) {
    // 1. Nghĩ: gửi toàn bộ lịch sử + danh sách tool cho model
    const response = await client.messages.create({
      model: "claude-opus-5-5",
      max_tokens: 16000,
      tools,
      messages,
    });
    messages.push({ role: "assistant", content: response.content });

    // Model không gọi tool nữa: xong việc, hoặc bị cắt (max_tokens), bị từ chối (refusal)
    if (response.stop_reason !== "tool_use") {
      console.log("Dừng vì:", response.stop_reason);
      return response;
    }

    // 2. Gọi tool + 3. Quan sát: chạy từng tool model yêu cầu
    const toolResults: Anthropic.ToolResultBlockParam[] = [];
    for (const block of response.content) {
      if (block.type !== "tool_use") continue;
      console.log(`[step ${step}] ${block.name}`, block.input);
      toolResults.push({
        type: "tool_result",
        tool_use_id: block.id,
        ...(await executeTool(block.name, block.input)),
      });
    }
    // 4. Lặp lại: đưa kết quả thật từ môi trường vào context
    messages.push({ role: "user", content: toolResults });
  }
  throw new Error(`Quá ${MAX_STEPS} bước, dừng để người xem xét`);
}

Chạy thử: cài SDK bằng npm i @anthropic-ai/sdk, đặt biến ANTHROPIC_API_KEY, rồi gọi runAgent("Chạy test, đọc các file liên quan và giải thích vì sao test fail. Chưa sửa code."). Agent này cố ý chỉ có quyền đọc và chạy test. Muốn nó tự sửa, bạn thêm tool write_file, và đó cũng là lúc guardrail cùng việc review diff trở nên bắt buộc.

Vài điều đáng chú ý:

• Model không tự chạy gì cả. Nó chỉ trả về block tool_use, code của bạn quyết định có chạy hay không. Đây là chỗ đặt guardrail.
• Toàn bộ lịch sử được gửi lại mỗi vòng, nên context phình dần theo số bước. Agent chạy lâu vừa tốn tiền vừa dễ "lạc".
• Lỗi của tool cũng là dữ liệu cho model. Trả lỗi về qua tool_result với is_error: true thay vì throw, model sẽ đọc lỗi và thử cách khác. Throw ra ngoài thì cả vòng lặp dừng.
• Kết quả tool là dữ liệu chưa được tin cậy, có thể chứa chữ nhằm điều khiển model (xem phần prompt injection bên dưới).

Làm agent thật thì bạn thường không cần tự viết vòng lặp: Anthropic có tool runner (đang beta) trong SDK và Claude Agent SDK (đóng gói tool, agent loop, quản context của Claude Code), OpenAI có Agents SDK. Nhưng viết tay một lần giúp bạn hiểu framework đang làm gì bên dưới. Chưa quen type trong đoạn code trên thì xem lại TypeScript là gì.

Coding agent: ví dụ trưởng thành nhất hiện nay

Anthropic đánh giá lập trình là một trong những mảng agent hứa hẹn nhất, vì code có phản hồi khách quan: compiler báo lỗi, test pass hoặc fail. Agent có "ground truth" rõ ràng để tự sửa. Tình hình các công cụ chính tới đầu tháng 10/2026:

Xu hướng chung: từ "agent ngồi cạnh bạn trong editor" sang "agent chạy nền trên cloud, bạn review kết quả". Muốn so sánh chi tiết, xem Cursor vs Copilot vs Claude Code hoặc bài riêng về Claude Code và GitHub Copilot.

Agent hay hỏng ở đâu

Lỗi cộng dồn. Anthropic cảnh báo tính tự chủ của agent kéo theo chi phí cao hơn và nguy cơ lỗi cộng dồn. Một giả định sai ở bước 2 được xây tiếp ở các bước sau, càng nhiều bước càng khó gỡ.

Làm quá nhiều một lúc, tuyên bố xong quá sớm. Khi cho agent build ứng dụng qua nhiều phiên, Anthropic thấy agent hay cố làm cả app một lần, hoặc tự kết luận là xong mà chưa kiểm tra end-to-end. Cách họ khắc phục: làm từng tính năng một, ghi file tiến độ, commit git thường xuyên, cho agent tool test qua trình duyệt.

Chi phí và độ trễ. Mỗi vòng lặp gửi lại toàn bộ context, nên task vài chục bước tốn hơn nhiều so với một lời gọi API đơn lẻ.

Prompt injection. Anthropic viết rằng mọi tài nguyên bên ngoài đưa cho agent (trang web, issue, README, MCP server) vừa là rủi ro thực thi code, vừa là kênh prompt injection. Output của tool cũng là bề mặt tấn công, kể cả khi tool đáng tin.

Vượt quyền. Agent có quyền chạy lệnh thì có thể xoá nhầm file hay đụng vào database. Checkpoint của Claude Code hoàn tác được thay đổi file, nhưng thao tác lên hệ thống bên ngoài như database, API, deployment thì không.

Hướng dẫn an toàn từ các nhà phát triển

• Giới hạn bằng môi trường trước, bằng prompt sau. Anthropic chủ trương đặt ranh giới ở tầng môi trường (sandbox, VM, giới hạn filesystem và network) trước, rồi mới điều hướng hành vi ở tầng model, vì mọi lớp phòng thủ mang tính xác suất đều có tỉ lệ lọt.
• Đừng trông vào nút "Allow". Telemetry của Anthropic cho thấy người dùng chấp nhận khoảng 93% yêu cầu xin quyền. Bấm duyệt thành phản xạ thì lớp bảo vệ này yếu đi rất nhiều, nên Anthropic chuyển trọng tâm sang sandbox và giới hạn ở tầng môi trường.
• Chấm mức rủi ro cho từng tool. OpenAI khuyên xếp tool theo mức thấp, trung bình, cao (đọc hay ghi, đảo ngược được không, ảnh hưởng tài chính), rồi bắt kiểm tra thêm trước tool rủi ro cao.
• Chuyển cho người khi cần: khi vượt ngưỡng số lần thất bại, hoặc trước hành động nhạy cảm, không thể đảo ngược.

Trong thực tế: chạy agent trong container hoặc sandbox, không đưa credential production cho agent, giới hạn network, luôn review diff trước khi merge.

Khi nào KHÔNG nên dùng agent

Lời khuyên của Anthropic khá thẳng: tìm giải pháp đơn giản nhất có thể, chỉ tăng độ phức tạp khi thật sự cần. Nhiều khi một lời gọi LLM tốt, kèm retrieval và vài ví dụ, là đủ. OpenAI cũng nói nếu use case không thật sự cần, một giải pháp deterministic có thể là đủ. Tự hỏi trước khi xây agent:

• Các bước có biết trước không? Có thì viết workflow, dễ test và debug hơn nhiều.
• Kết quả có đáng với chi phí và độ trễ không?
• Sai thì có phát hiện và sửa được không? Có test, review, rollback thì mới nên cho agent tự chạy.
• Một agent đã đủ chưa? OpenAI khuyên tận dụng tối đa một agent trước, chỉ tách nhiều agent khi agent chọn sai tool liên tục hoặc không theo được chỉ dẫn phức tạp.

Ví dụ: tóm tắt ticket support và gán nhãn là việc của một lời gọi LLM. Dịch tài liệu rồi kiểm tra thuật ngữ là workflow. "Tìm nguyên nhân test flaky trong một repo lớn" mới là việc của agent.

Điều này có ý nghĩa gì với lập trình viên

Agent thay đổi phần việc của dev, không làm biến mất người dev. Những kỹ năng được coi trọng hơn:

• Chia việc và mô tả yêu cầu rõ ràng. Agent làm tốt khi mục tiêu cụ thể và kiểm chứng được. Xem thêm prompt cho lập trình.
• Review code. Bạn đọc nhiều hơn gõ. AI review có thể hỗ trợ, nhưng người chịu trách nhiệm cuối cùng cho diff vẫn là bạn, và bạn cần đủ hiểu hệ thống để nhận ra khi agent đi lạc.
• Viết test. Test là "ground truth" của agent. Repo có test tốt thì agent làm tốt hơn.

Nếu bạn lo bị thay thế, bài AI có thay thế lập trình viên không phân tích kỹ hơn.

Tóm lại

AI agent là LLM chạy trong vòng lặp: tự chọn tool, nhận phản hồi thật từ môi trường, tự quyết định bước tiếp theo. Nó mạnh ở task mở có phản hồi rõ ràng như code, yếu ở lỗi cộng dồn, chi phí và prompt injection. Bắt đầu đơn giản, thêm agent khi thật cần, và đặt giới hạn ở tầng môi trường.

Muốn làm chủ agent, bạn cần nền đủ chắc để phán xét code nó viết. Nếu làm frontend, khóa React PRO của HoleTex giúp bạn nắm React đủ sâu để review code do AI sinh ra. Muốn rèn tư duy chia bài toán, thứ việc giao task cho agent đòi hỏi rất nhiều, hãy thử luyện thuật toán trên HoleTex Algo.

Bài liên quan

• Claude Code là gì
• GitHub Copilot là gì
• MCP là gì
• Context engineering là gì
• Lập trình với AI 2026: bản đồ toàn cảnh

Nguồn tham khảo: Building effective agents (anthropic.com), Effective harnesses for long-running agents (anthropic.com), How we contain Claude across products (anthropic.com), A practical guide to building agents (openai.com), How Claude Code works (code.claude.com), Handle tool calls (platform.claude.com), Agent SDK overview (code.claude.com), About Copilot cloud agent (docs.github.com), Cursor changelog (cursor.com), GitHub Copilot changelog (github.blog), Claude Haiku 5.5 (anthropic.com), Codex releases (github.com), Codex docs (learn.chatgpt.com), Antigravity 2.0 overview (antigravity.google). Cập nhật 2026-10-08.