Subagent: chia việc cho nhiều AI cùng làm

Bài này dựa trên tài liệu Claude Code về subagent và hai bài kỹ thuật của Anthropic, đọc ngày 11/11/2026. Một số bài viết trên mạng ghi rằng subagent không thể tạo thêm subagent; tài liệu hiện hành nói khác (xem mục giới hạn). Công cụ đổi nhanh, nên hãy đối chiếu với tài liệu khi làm.

Subagent là gì?

Theo tài liệu Claude Code, subagent là một trợ lý AI chuyên biệt xử lý một loại việc cụ thể. Nó chạy trong cửa sổ ngữ cảnh (context window) riêng, với chỉ dẫn hệ thống riêng, quyền dùng công cụ riêng và quyền hạn độc lập. Khi agent chính gặp một việc khớp với phần mô tả của một subagent, nó giao việc cho subagent; subagent làm độc lập rồi trả kết quả về.

Hãy hình dung bạn là trưởng nhóm. Bạn cần biết trong 30 tệp mã, tệp nào còn ghi chú TODO. Bạn có thể tự mở từng tệp, và sau đó đầu bạn đầy những dòng code không cần nhớ. Hoặc bạn nhờ một bạn trong nhóm đọc hết rồi đưa lại danh sách năm tệp. Subagent là bạn trong nhóm đó: làm phần việc nặng, chỉ báo lại kết quả.

Trong cách phân loại của Anthropic (xem AI agent là gì), đây là mẫu "điều phối viên và thợ" (orchestrator-workers): một mô hình trung tâm chia việc, giao cho các mô hình khác, rồi tổng hợp.

Vì sao cần subagent: giữ ngữ cảnh chính gọn

Ngữ cảnh của agent là tài nguyên có hạn. Tài liệu Claude Code giải thích: mọi thứ agent đọc (lịch sử trò chuyện, nội dung tệp, kết quả lệnh) đều nằm trong ngữ cảnh; khi gần đầy, cuộc trò chuyện bị nén thành bản tóm tắt, và chỉ dẫn đưa ra từ đầu có thể bị mất. Một lần tìm kiếm rộng có thể đổ vào ngữ cảnh hàng chục nghìn ký tự mà bạn sẽ không bao giờ cần đọc lại.

Theo tài liệu, subagent giữ những đầu ra phụ đó ngoài cuộc trò chuyện chính: nó làm việc trong ngữ cảnh của mình và chỉ trả về bản tóm tắt. Đoạn code dưới đây mô phỏng điều này bằng con số cụ thể. Một dự án giả có 30 tệp, mỗi tệp 200 dòng, vài tệp có TODO. Cùng việc tìm TODO được làm theo hai cách: agent chính tự đọc hết, hoặc giao cho subagent.

"""Mô phỏng vì sao subagent giữ ngữ cảnh chính gọn: cùng một việc tìm kiếm, làm thẳng hoặc giao cho subagent.

Ngữ cảnh ở đây là danh sách các đoạn chữ mà "mô hình" phải nhìn thấy; độ dài tính bằng ký tự cho dễ đếm.
Đây là mô phỏng để thấy cơ chế, không phải số đo của một công cụ thật.
"""

# Dự án giả: 30 tệp, mỗi tệp 200 dòng; vài tệp có ghi chú TODO.
DU_AN = {
    f"src/mo_dun_{i:02d}.py": ("# TODO: viết test cho hàm này\n" if i % 7 == 0 else "") + "x = 1\n" * 200
    for i in range(30)
}


def tim_todo(ngu_canh):
    """Đọc từng tệp (nội dung đọc được đi vào ngu_canh), trả về các tệp có TODO."""
    tim_thay = []
    for ten, noi_dung in DU_AN.items():
        ngu_canh.append(f"[đọc {ten}]\n{noi_dung}")
        if "TODO" in noi_dung:
            tim_thay.append(ten)
    return tim_thay


def tong(ngu_canh):
    return sum(len(doan) for doan in ngu_canh)


def lam_thang():
    """Agent chính tự đọc hết: mọi nội dung tệp nằm lại trong ngữ cảnh chính."""
    chinh = ["Yêu cầu: tìm các tệp còn TODO"]
    kq = tim_todo(chinh)
    chinh.append(f"Kết quả: {kq}")
    return kq, tong(chinh), 0


def giao_subagent():
    """Agent chính giao việc: subagent đọc trong ngữ cảnh riêng, chỉ bản tóm tắt quay về."""
    chinh = ["Yêu cầu: tìm các tệp còn TODO", "Giao cho subagent: đọc src/, trả về danh sách tệp có TODO"]
    rieng = ["Nhiệm vụ: đọc src/, trả về danh sách tệp có TODO, không sửa gì"]
    kq = tim_todo(rieng)
    chinh.append(f"Subagent trả về: {kq}")
    return kq, tong(chinh), tong(rieng)


def chay_thu():
    kq1, chinh1, _ = lam_thang()
    kq2, chinh2, rieng2 = giao_subagent()
    print(f"Làm thẳng:     ngữ cảnh chính {chinh1} ký tự")
    print(f"Giao subagent: ngữ cảnh chính {chinh2} ký tự, subagent dùng riêng {rieng2} ký tự")
    print(f"Cùng kết quả: {kq1 == kq2} -> {kq2}")
    return kq1, chinh1, kq2, chinh2, rieng2


if __name__ == "__main__":
    chay_thu()

Chạy đoạn code sẽ in ra:

Làm thẳng:     ngữ cảnh chính 36978 ký tự
Giao subagent: ngữ cảnh chính 203 ký tự, subagent dùng riêng 36902 ký tự
Cùng kết quả: True -> ['src/mo_dun_00.py', 'src/mo_dun_07.py', 'src/mo_dun_14.py', 'src/mo_dun_21.py', 'src/mo_dun_28.py']

Có hai điều cần đọc từ con số. Thứ nhất, ngữ cảnh chính nhỏ đi gần 200 lần, nên các bước sau của agent chính có chỗ cho việc quan trọng hơn. Thứ hai, tổng ký tự không giảm: 203 cộng 36.902 còn lớn hơn 36.978 một chút, vì có thêm câu giao việc. Subagent không làm việc đọc biến mất, nó chỉ dời việc đó sang chỗ khác. Đây là mô phỏng để thấy cơ chế; trong công cụ thật, mỗi lượt của subagent còn tốn thêm phần chỉ dẫn hệ thống của nó.

Cái giá: subagent tốn thêm token

Anthropic có công bố số liệu từ hệ thống nghiên cứu nhiều agent của họ (bài kỹ thuật ngày 13/06/2025): agent thường dùng khoảng 4 lần lượng token so với trò chuyện thường, còn hệ nhiều agent dùng khoảng 15 lần. Cùng bài đó cho biết hệ nhiều agent làm tốt hơn một agent đơn lẻ 90,2% trên bộ đánh giá nghiên cứu nội bộ của họ, nhưng chỉ đáng với việc có giá trị đủ cao để bù chi phí.

Tài liệu Claude Code cũng ghi rõ: yêu cầu của subagent tính chung vào cùng hạn mức sử dụng với cuộc trò chuyện chính. Vì vậy subagent là công cụ để giữ ngữ cảnh gọn và chạy song song, không phải để tiết kiệm. Tài liệu có gợi ý một cách giảm chi phí: cho subagent làm việc đơn giản dùng mô hình rẻ hơn. Bài chi phí khi dùng agent bàn kỹ về hạn mức và cách tiết kiệm.

Khi nào nên dùng subagent, khi nào không?

Bài của Anthropic nêu rõ hệ nhiều agent hợp với việc có nhiều phần chạy song song, lượng thông tin vượt quá một cửa sổ ngữ cảnh, và cần nhiều công cụ phức tạp. Ngược lại, nó không hợp với việc mà mọi agent cần cùng một ngữ cảnh, hoặc các agent phụ thuộc lẫn nhau nhiều. Bài viết nói thẳng: phần lớn việc lập trình thuộc nhóm không hợp này, vì có ít phần việc tách song song được hơn việc nghiên cứu.

Một quy tắc đơn giản: nếu bạn có thể mô tả việc đó trong vài câu, ghi được rõ "trả về cái gì", và kết quả không cần biết những gì đã bàn trong cuộc trò chuyện chính, thì việc đó hợp để giao subagent.

Giao việc cho subagent sao cho tốt

Subagent bắt đầu với ngữ cảnh trống (trừ khi là bản rẽ nhánh, xem bên dưới), nên nó chỉ biết những gì bạn hoặc agent chính viết trong lời giao việc. Bài của Anthropic rút ra bài học: agent chính phải cho mỗi subagent biết mục tiêu, định dạng kết quả, hướng dẫn dùng công cụ và nguồn nào, và ranh giới việc rõ ràng; chỉ dẫn mơ hồ làm các subagent làm trùng nhau hoặc bỏ sót.

Một lời giao việc tốt gồm bốn phần:

1. Mục tiêu: "tìm mọi chỗ gọi hàm gui_email trong thư mục src/".
2. Định dạng kết quả: "trả về danh sách dạng tệp:dòng, không quá 20 dòng".
3. Phạm vi và giới hạn: "chỉ đọc, không sửa tệp nào; bỏ qua thư mục tests/".
4. Điều đã biết: "hàm này được định nghĩa ở src/thong_bao.py, đừng tính chỗ đó".

Bài của Anthropic còn kể một chi tiết đáng nhớ: phiên bản đầu của hệ thống từng tạo tới 50 subagent cho những câu hỏi đơn giản, nên họ phải thêm quy tắc rõ ràng về số lượng: việc tra cứu đơn giản dùng một agent với 3 đến 10 lần gọi công cụ, việc so sánh dùng 2 đến 4 subagent, và chỉ việc nghiên cứu phức tạp mới dùng hơn 10 subagent. Bài học cho người dùng: đừng mặc định chia nhỏ, hãy chia khi có lý do.

Subagent trong Claude Code

Subagent có sẵn

Theo tài liệu, Claude Code có sẵn vài subagent:

Agent chính tự giao việc cho các subagent này khi phù hợp. Bạn cũng có thể nhờ thẳng, ví dụ "dùng subagent để tìm mọi chỗ đọc biến môi trường trong dự án".

Tự tạo subagent

Subagent tự tạo là tệp Markdown có khối YAML ở đầu; phần thân trở thành chỉ dẫn hệ thống của subagent. Ví dụ theo tài liệu:

---
name: code-reviewer
description: Reviews code for quality and best practices
tools: Read, Glob, Grep
model: sonnet
---

You are a code reviewer. When invoked, analyze the code and provide
specific, actionable feedback on quality, security, and best practices.

Chỉ name và description là bắt buộc. Trường tools liệt kê các công cụ được dùng (bỏ trống thì kế thừa công cụ có sẵn), trường model chọn mô hình. Subagent ví dụ ở trên chỉ được đọc và tìm kiếm, đúng với việc duyệt code: người duyệt không cần quyền sửa.

Tệp đặt ở .claude/agents/ (cho dự án, commit để cả nhóm dùng) hoặc ~/.claude/agents/ (cho mọi dự án của bạn). Khi trùng tên, vị trí ưu tiên cao hơn thắng; thứ tự ưu tiên trong tài liệu là: cấu hình do tổ chức quản lý, cờ dòng lệnh, thư mục dự án, thư mục người dùng, rồi plugin. Tài liệu cũng gợi ý có thể nhờ chính Claude Code tạo subagent, ví dụ: tạo một subagent cá nhân trong ~/.claude/agents/ để quét tệp và gợi ý cải thiện, chỉ được đọc, dùng mô hình Sonnet.

Như với skill, phần description quyết định khi nào agent chính giao việc. Tài liệu khuyên giữ mô tả ngắn vì mô tả cũng chiếm ngữ cảnh; Claude Code cảnh báo khi tổng mô tả của các subagent tự tạo vượt khoảng 15.000 token.

Giới hạn và rẽ nhánh

Theo tài liệu hiện hành, mặc định một subagent có thể tạo tiếp subagent, sâu tối đa ba tầng tính từ cuộc trò chuyện chính, và một phiên cho phép 20 subagent chạy cùng lúc. Cả hai giới hạn chỉnh được bằng biến môi trường. Ngoài subagent bắt đầu với ngữ cảnh trống, còn có kiểu rẽ nhánh (fork): bắt đầu với bản sao cuộc trò chuyện tới thời điểm đó. Dù kiểu nào, các lệnh gọi công cụ của subagent không đi vào ngữ cảnh của bạn, và agent chính nhận bản tóm tắt khi subagent xong.

Subagent khác skill thế nào?

Hai khái niệm này hay bị lẫn vì đều là tệp Markdown có khối YAML với name và description. Khác biệt nằm ở chỗ nội dung được dùng như thế nào:

Hai thứ có thể đi cùng nhau: tài liệu cho biết subagent có trường skills, và skill có thể chạy trong một subagent rẽ nhánh. Xem Agent Skills là gì.

Câu hỏi thường gặp

Học tiếp

• Muốn biết subagent nằm ở đâu trong bức tranh agent, đọc AI agent là gì.
• Muốn tính chi phí khi chạy nhiều agent, đọc chi phí khi dùng agent.
• Muốn dùng subagent để đọc nhanh một kho mã lớn, đọc dùng AI đọc hiểu một kho mã lớn.

Nếu bạn muốn học nền tảng AI một cách có hệ thống cùng giảng viên, tham khảo khóa học AI của Big-O Coding.

Nguồn tham khảo

• Tài liệu Claude Code: Subagents
• Tài liệu Claude Code: How Claude Code works
• Anthropic Engineering: How we built our multi-agent research system (13/06/2025)
• Anthropic: Building effective agents (19/12/2024)