Cùng xây dựng bộ khung (harness) cho Claude Code (từng bước một)

Chúng tôi sẽ trình bày tất cả những gì cần thiết để xây dựng một bộ khung lập trình (coding harness), vòng lặp tác nhân (agent loop), lập kế hoạch, tác nhân phụ (subagents), sandbox, bộ nhớ và checkpointing, được xây dựng từng bước một.

Nếu bạn từng thử xây dựng tác nhân lập trình của riêng mình, bạn sẽ hiểu điều này. Bạn kết nối một mô hình với các công cụ tệp và một shell, hướng nó vào một mã nguồn thực tế, và nó sẽ hỏng sau vài chục lần gọi công cụ.

Nó đọc sai tệp, đánh mất mục tiêu giữa chừng, và lấp đầy ngữ cảnh bằng những kết quả mà nó không cần nữa.

Rồi cùng một tác vụ đó được chạy qua Claude Code và hoàn thành một cách sạch sẽ. Kết luận dễ dàng là Anthropic đơn giản có một mô hình tốt hơn, và kết luận đó đã bỏ lỡ nơi công việc thực sự diễn ra.

Sự khác biệt nằm ở bộ khung (harness). Bộ khung là mã thông thường được bao quanh mô hình, nó xử lý việc lập kế hoạch, thực thi công cụ, bộ nhớ và an toàn, trong khi mô hình chỉ quyết định bước tiếp theo.

Đây là hình ảnh của một tác nhân được trang bị đầy đủ bộ khung trông như thế nào:

GIF

Bức tranh trông có vẻ phức tạp, nhưng nó được chia thành bốn nhóm:

• Bộ nhớ cung cấp cho mô hình ngữ cảnh làm việc cùng với các dữ kiện đã học được qua các phiên.
• Kỹ năng mã hóa cách tác nhân nên vận hành, nghĩa là các quy trình, ràng buộc và kinh nghiệm thực tiễn (heuristics) mà nó tuân theo.
• Giao thức kết nối tác nhân với người dùng, công cụ và các tác nhân khác.
• Lõi bộ khung kết nối tất cả lại với nhau thông qua điều phối tác nhân phụ, một sandbox, một bộ đánh giá, một vòng lặp phê duyệt, khả năng quan sát và nén ngữ cảnh.

Anthropic mô tả sự phân chia này là bộ não và đôi tay. Mô hình là bộ não chọn từng hành động, và bộ khung là đôi tay thực hiện hành động đó và giữ cho quá trình chạy đúng hướng.

Vì vậy, khoảng cách giữa tác nhân của bạn và Claude Code không phải là mô hình, mà là hệ thống máy móc xung quanh mô hình.

Claude Code là một trong những bộ khung có năng lực nhất hiện nay, và nó được xây dựng từ một tập hợp nhỏ đáng ngạc nhiên các lớp trong hình minh họa đó. Để thấy có bao nhiêu phần trong hệ thống máy móc đó bạn phải tự xây dựng, tôi đã xây dựng lại nó trong CrewAI, một framework mã nguồn mở để điều phối các tác nhân.

Nhiều phần hơn tôi mong đợi được ánh xạ vào các tính năng có sẵn, và phần không được ánh xạ chính là nơi công việc kỹ thuật thực sự diễn ra.

Hãy xây dựng nó từng lớp một, bắt đầu với vòng lặp cốt lõi và xếp chồng lên đó kế hoạch, tác nhân phụ, sandbox và bộ nhớ. Ở mỗi bước, chúng ta sẽ đánh dấu nơi framework kết thúc và nơi công việc của bạn bắt đầu.

Bộ khung của Claude Code hoạt động như thế nào

Trung tâm của Claude Code là một vòng lặp tác nhân đơn giản. Bạn gửi cho nó một tin nhắn, mô hình quyết định làm gì tiếp theo, và nó hoặc phản hồi trực tiếp hoặc yêu cầu một công cụ. Nếu nó yêu cầu, công cụ sẽ chạy, kết quả được đưa trở lại cuộc trò chuyện, và mô hình lại quyết định.

Quá trình này lặp lại cho đến khi mô hình trả về câu trả lời cuối cùng mà không có thêm yêu cầu công cụ nào.

Bên trong vòng lặp đó, mô hình đọc tệp, chỉnh sửa mã, chạy lệnh shell và thực thi kiểm thử. Đây không phải là các chế độ riêng biệt. Chúng chỉ là các lệnh gọi công cụ khác nhau trong cùng một vòng lặp.

Tuy nhiên, chỉ riêng vòng lặp là không đủ cho một tác nhân lập trình đáng tin cậy. Claude Code thêm vào đó lập kế hoạch, công cụ tệp, tác nhân phụ, bộ nhớ và một hệ thống phân quyền và sandbox xung quanh nó. Các lớp này không thay thế vòng lặp, chúng làm cho nó đủ an toàn và đáng tin cậy cho công việc thực tế.

Đó là kiến trúc chúng ta sẽ xây dựng lại, đầu tiên là vòng lặp cốt lõi, sau đó là từng lớp trên đó, ánh xạ mỗi lớp vào tính năng CrewAI xử lý nó.

Vòng lặp tác nhân cốt lõi

Vòng lặp chạy cùng một trình tự cho đến khi hoàn thành tác vụ:

1. Yêu cầu mô hình thực hiện tác vụ.
2. Mô hình phản hồi trực tiếp hoặc yêu cầu một hoặc nhiều công cụ.
3. Nếu có yêu cầu công cụ, chạy chúng và trả kết quả về cho mô hình.
4. Lặp lại với cuộc trò chuyện đã được cập nhật.
5. Khi mô hình phản hồi mà không yêu cầu bất kỳ công cụ nào, tác vụ hoàn thành.

1while True:
2    reply = model(messages, tools)
3    calls = [b for b in reply if b.type == "tool_use"]
4    if not calls:            # văn bản thường, không có yêu cầu công cụ: công việc đã xong
5        return reply.text
6    messages += [reply, run_all(calls)]

Mỗi lần gọi công cụ hoàn thành một bước, cung cấp cho mô hình thông tin mới và đưa vào quyết định tiếp theo. Một câu hỏi đơn giản có thể kết thúc trong một lần lặp, trong khi sửa một lỗi phức tạp hoặc tái cấu trúc một mã nguồn lớn có thể mất hàng chục lần lặp trước khi mô hình có đủ thông tin để đưa ra câu trả lời cuối cùng.

CrewAI cung cấp vòng lặp thực thi này một cách tự động ngay khi bạn tạo một tác nhân. Bạn không tự thực hiện vòng lặp while, bạn định nghĩa tác nhân và gán cho nó một tác vụ.

Xây dựng tác nhân đầu tiên

Hãy tạo một tác nhân Sửa lỗi (Bug Fixer) đơn giản.

1from crewai import LLM, Agent, Crew, Task
2
3bug_fixer = Agent(
4    role="Bug Fixer",
5    goal="Tìm và mô tả cách sửa lỗi được báo cáo trong mã nguồn.",
6    backstory="Bạn đọc các thư mục và tệp để xây dựng một bức tranh chính xác về mã.",
7    llm="claude-sonnet-4-6",
8)
9
10task = Task(
11    description="Tìm cách sửa lỗi cho {objective}.",
12    expected_output="Một mô tả ngắn gọn về cách sửa lỗi và tệp nào chứa nó.",
13)
14
15result = Crew(agents=[bug_fixer], tasks=[task]).kickoff(
16    inputs={"objective": "lỗi thấu chi (overdraft) trong account.py"}
17)

Ba khái niệm cần hiểu ở đây:

• Agent (Tác nhân) định nghĩa ai làm công việc, thông qua vai trò, mục tiêu, LLM và các công cụ.
• Task (Tác vụ) mô tả nhiệm vụ được giao.
• Crew (Nhóm) kết hợp các tác nhân và tác vụ. Gọi kickoff() sẽ chạy cùng một vòng lặp thực thi đã mô tả ở trên, bất kể mô hình nền tảng là Anthropic, OpenAI, Google hay bất kỳ hãng nào khác.

Cung cấp công cụ cho tác nhân

Công cụ là thứ cho phép một mô hình chỉ tạo văn bản thực sự làm việc trên mã nguồn. Chúng đọc tệp, ghi tệp, chạy lệnh shell và gọi các API bên ngoài.

CrewAI cung cấp sẵn các công cụ hệ thống tệp:

• FileReadTool đọc tệp.
• DirectoryReadTool liệt kê thư mục.
• FileWriterTool ghi tệp.

1from crewai_tools import DirectoryReadTool, FileReadTool, FileWriterTool
2
3read_file = FileReadTool()
4write_file = FileWriterTool()
5list_dir = DirectoryReadTool()
6
7filesystem_tools = [read_file, write_file, list_dir]

Các công cụ này cũng đóng vai trò như bộ nhớ bên ngoài. Thay vì giữ một kết quả tìm kiếm lớn trong cửa sổ ngữ cảnh của mô hình, tác nhân có thể ghi nó vào một tệp, chỉ giữ lại tên tệp và đọc lại khi cần.

Điều này giúp cửa sổ ngữ cảnh nhỏ hơn và mô hình tập trung hơn, đó là điều Anthropic gọi là kỹ thuật ngữ cảnh (context engineering).

Các công cụ tích hợp chỉ bao phủ các quy trình làm việc phổ biến. Đối với bất kỳ thứ gì cụ thể hơn, bạn có thể hiển thị một hàm Python như một công cụ với decorator @tool.

Docstring (chuỗi tài liệu) đóng vai trò như sách hướng dẫn, cho mô hình biết công cụ làm gì, khi nào sử dụng nó và nó mong đợi đầu vào gì.

1from crewai.tools import tool
2import subprocess
3
4@tool("run_tests")
5def run_tests(path: str = "tests/") -> str:
6    """Chạy bộ kiểm thử pytest tại đường dẫn đã cho và trả về kết quả."""
7    result = subprocess.run(
8        ["pytest", path, "-q"], capture_output=True, text=True, timeout=120
9    )
10    output = result.stdout + result.stderr
11    return output[-4000:] if len(output) > 4000 else output

Lập kế hoạch cho các tác vụ chạy dài

Khi các tác vụ trở nên phức tạp hơn, một vòng lặp thực thi đơn giản bắt đầu đánh mất mục tiêu ban đầu. Sau đủ nhiều lần gọi công cụ, đọc tệp và kết quả trung gian, ngữ cảnh bị đầy và mục tiêu bị lấn át bởi mọi thứ đến sau nó.

Sự suy giảm chậm này được gọi là mục nát ngữ cảnh (context rot).

Lập kế hoạch giải quyết trực tiếp vấn đề này. Tác nhân xây dựng một kế hoạch từng bước trước khi thực hiện bất kỳ công việc nào và giữ kế hoạch đó trong ngữ cảnh trong suốt quá trình thực thi.

Kế hoạch không thực hiện công việc. Nó là một lộ trình giữ cho mô hình kết nối với mục tiêu ban đầu, đó là công việc tương tự mà danh sách việc cần làm (to-do list) của Claude Code thực hiện.

CrewAI thêm tính năng này ở cấp độ crew với planning=True. Nó tạo ra một kế hoạch trước khi thực thi và giữ nó có sẵn khi tác vụ tiến triển.

1from crewai import Crew, LLM
2
3crew = Crew(
4    agents=self.agents,
5    tasks=self.tasks,
6    planning=True,
7    planning_llm=LLM(model="gpt-4o-mini"),
8)

Lưu ý: Theo mặc định, CrewAI sử dụng gpt-4o-mini để lập kế hoạch, và bạn có thể thay thế bất kỳ LLM nào bạn muốn cho bước đó.

Các tác nhân riêng lẻ cũng có thể suy luận về công việc của chính mình với reasoning=True:

1from crewai import Agent
2
3bug_fixer = Agent(
4    role="Bug Fixer",
5    goal="Tìm và mô tả cách sửa lỗi được báo cáo trong mã nguồn.",
6    backstory="Bạn đọc các thư mục và tệp để xây dựng một bức tranh chính xác về mã.",
7    tools=[FileReadTool()],
8    reasoning=True,
9    max_reasoning_attempts=3  # Tùy chọn: Đặt số lần suy luận tối đa
10)

Lập kế hoạch và suy luận giải quyết các vấn đề khác nhau. Lập kế hoạch xây dựng một lộ trình cấp cao cho toàn bộ tác vụ, trong khi suy luận cho một tác nhân thời gian để suy nghĩ về cách tiếp cận của riêng nó trước khi hành động.

Khi suy luận được bật, tác nhân sẽ:

1. Suy ngẫm về tác vụ và phác thảo một kế hoạch thực thi.
2. Đánh giá xem kế hoạch đã sẵn sàng chưa.
3. Tinh chỉnh kế hoạch nếu cần, cho đến khi nó hài lòng hoặc đạt đến max_reasoning_attempts.
4. Đưa kế hoạch suy luận đã hoàn thiện vào tác vụ trước khi thực thi.

Cùng nhau, chúng giữ cho tác nhân bám sát các tác vụ chạy dài và giảm sự lệch hướng khỏi mục tiêu ban đầu.

Ủy quyền với tác nhân phụ

Lập kế hoạch giữ cho tác nhân tập trung, nhưng nó không làm giảm lượng thông tin mà mô hình phải giữ. Trên một mã nguồn lớn, ngay cả một tác vụ được lập kế hoạch tốt cũng có thể vượt quá một cửa sổ ngữ cảnh duy nhất.

Việc tìm một lỗi có thể yêu cầu đọc hàng chục tệp, và tác nhân chính không cần giữ tất cả chúng trong bộ nhớ.

Các tác nhân phụ giải quyết vấn đề này thông qua ủy quyền. Tác nhân chính giao một tác vụ cụ thể cho một tác nhân trợ giúp, tác nhân này làm việc trong ngữ cảnh riêng của nó và trả về một bản tóm tắt ngắn gọn. Tác nhân chính thấy kết luận, không phải các bước trung gian.

CrewAI hỗ trợ điều này thông qua các quy trình làm việc phân cấp (hierarchical workflows), nơi một tác nhân quản lý ủy quyền cho các tác nhân chuyên gia và kết hợp kết quả của họ.

Trong thiết lập trước đó của chúng ta, một tác nhân Sửa lỗi đã làm tất cả công việc nặng nhọc. Hãy chia công việc cho một người quản lý và ba chuyên gia:

• Codebase Explorer (Người khám phá mã nguồn) khám phá mã và lập bản đồ kho lưu trữ.
• Software Engineer (Kỹ sư phần mềm) thực hiện thay đổi được yêu cầu.
• Test Runner (Người chạy kiểm thử) chạy các bài kiểm thử trong sandbox và báo cáo đỗ hay trượt.
• Engineering Lead (Trưởng nhóm kỹ thuật) giám sát ba chuyên gia.

1from crewai import Crew, Agent, Task, Process
2
3explorer = Agent(
4    role="Codebase Explorer",
5    goal="Lập bản đồ kho lưu trữ và đưa ra các tệp liên quan đến tác vụ.",
6    backstory="Bạn đọc các thư mục và tệp để xây dựng một bức tranh về mã.",
7    tools=[read_file, list_dir],
8    llm=llm,
9)  # Tương tự cho hai tác nhân chuyên gia khác
10
11manager = Agent(
12    role="Engineering Lead",
13    goal="Chia yêu cầu thành các bước và ủy quyền từng bước cho đúng chuyên gia.",
14    backstory="Bạn quyết định ai làm gì, xem xét kiểm thử, kết thúc khi thay đổi hoàn tất.",
15    llm=llm,
16    allow_delegation=True,
17)
18
19crew = Crew(
20    agents=[explorer, coder, tester],
21    tasks=[task],
22    manager_agent=manager,
23    process=Process.hierarchical,
24)

Một điều cần lưu ý là allow_delegation bị tắt theo mặc định, vì vậy nó phải được bật một cách rõ ràng trên người quản lý.

Sandbox: Bảo mật thực thi tác nhân

Một tác nhân có quyền truy cập shell có thể chạy một lệnh phá hoại, và nói với mô hình đừng làm điều gì đó không phải là một biện pháp bảo vệ.

Sự bảo vệ thực sự đến từ hai lớp:

1. Một hệ thống phân quyền yêu cầu phê duyệt cho các hành động nhạy cảm.
2. Một sandbox cách ly thực thi, để ngay cả các lệnh đã được phê duyệt cũng không thể chạm vào máy chủ.

Anthropic sử dụng cùng một cách tiếp cận. Di chuyển thực thi mã vào một sandbox giúp giảm tần suất người dùng cần phê duyệt các hành động trong khi vẫn bảo vệ hệ thống máy chủ.

Sandbox trong CrewAI

Thực thi mã bên trong một sandbox thay vì trên máy chủ áp dụng lớp thứ hai đó. Trong thiết lập này, mã chạy bên trong E2B, nó khởi tạo một máy ảo mới cho mỗi phiên và hủy nó sau đó.

Các lệnh shell và Python chạy hoàn toàn trong môi trường biệt lập đó.

1from crewai_tools import E2BExecTool, E2BPythonTool
2sandbox_tools = [E2BExecTool(), E2BPythonTool()]  # chạy kiểm thử / chạy mã

Phê duyệt với sự tham gia của con người

Đặt human_input=True trên một Task sẽ tạm dừng nhóm (crew) sau khi nó tạo ra câu trả lời. Bạn xem xét đầu ra, sau đó phê duyệt nó hoặc gửi lại để lặp lại.

Khi thực thi đến tác vụ đó, CrewAI chờ phản hồi của bạn qua đầu vào tiêu chuẩn.

1from crewai import Task
2
3task = Task(
4    description=(
5        "Trong thư mục làm việc ./workspace, {objective}. "
6        "Khám phá mã trước, thực hiện thay đổi, sau đó chạy kiểm thử và báo cáo."
7    ),
8    expected_output="Một bản tóm tắt các tệp đã thay đổi và kết quả kiểm thử cuối cùng.",
9    human_input=True,
10)

Nếu nhóm của bạn chạy phía sau một ứng dụng web hoặc giao diện trò chuyện thay vì terminal, hệ thống phê duyệt có sự tham gia của con người dựa trên webhook của CrewAI xử lý cùng một bước xem xét.

Bộ nhớ và Checkpointing

Theo mặc định, một tác nhân quên mọi thứ khi một lần chạy kết thúc. Quay lại ngày mai để sửa một lỗi khác trong cùng một dự án, và nó bắt đầu từ con số không.

Hai cơ chế cho phép một tác nhân mang thông tin qua các lần chạy, và mỗi cơ chế phục vụ một mục đích khác nhau:

• Checkpointing lưu trạng thái của tác nhân trong một lần chạy, để nó có thể tiếp tục sau khi bị gián đoạn hoặc tiếp tục từ cùng một điểm theo một hướng khác.
• Bộ nhớ liên tục (Persistent memory) lưu trữ các dữ kiện qua các cuộc trò chuyện riêng biệt, bao gồm các tùy chọn dự án như "luôn định dạng mã cuối cùng trước khi hoàn thành."

Bộ nhớ trong CrewAI

CrewAI cung cấp một giao diện Bộ nhớ thống nhất thay vì các loại bộ nhớ riêng biệt như ngắn hạn, dài hạn, thực thể và bên ngoài. Khi lưu, nó sử dụng một LLM để xác định các chi tiết quan trọng, tổ chức chúng và làm cho chúng có thể truy xuất sau này.

Đặt memory=True trên crew sẽ cho nó bộ nhớ qua các lần chạy. Sau mỗi tác vụ, CrewAI trích xuất các dữ kiện hữu ích từ đầu ra và lưu trữ chúng, và trong các lần chạy trong tương lai, nó truy xuất các ký ức liên quan và thêm chúng vào lời nhắc tác vụ.

1from crewai import Crew
2
3crew = Crew(
4    agents=[explorer, coder, tester],
5    tasks=[task],
6    memory=True,
7)

Tất cả các tác nhân trong một crew chia sẻ bộ nhớ của nó trừ khi một tác nhân được cấp bộ nhớ riêng.

Checkpointing trong CrewAI

Checkpoint là một ảnh chụp nhanh tiến trình của tác nhân, bao gồm cấu hình, trạng thái tác vụ, bộ nhớ, kết quả trung gian, đầu vào và lịch sử thực thi.

Theo mặc định, CrewAI tạo một checkpoint bất cứ khi nào một tác vụ kết thúc, cho phép quy trình làm việc tiếp tục từ điểm đó nếu bị gián đoạn.

Checkpoints có thể nằm trong một trong hai kho lưu trữ tích hợp sẵn:

• JsonProvider lưu mỗi checkpoint dưới dạng một tệp JSON riêng biệt, dễ đọc và kiểm tra thủ công.
• SqliteProvider lưu trữ tất cả các checkpoint trong một cơ sở dữ liệu SQLite duy nhất, hoạt động tốt hơn dưới tần suất checkpointing thường xuyên và khối lượng công việc lớn hơn.

1from crewai import Crew
2
3crew = Crew(
4    agents=[explorer, coder, tester],
5    tasks=[task],
6    checkpoint=True,
7)

Crew, Flow và Agent đều chấp nhận đối số checkpoint và các thành phần con kế thừa từ thành phần cha trừ khi chúng đặt giá trị riêng.

Kết hợp tất cả lại với nhau

Đây là bộ khung hoàn chỉnh cho một tác vụ, với vòng lặp thực thi, công cụ, lập kế hoạch, tác nhân phụ, sandbox và bộ nhớ làm việc cùng nhau:

1from crewai import Agent, Crew, LLM, Process, Task
2from crewai.tools import tool
3from crewai_tools import (DirectoryReadTool, FileReadTool, FileWriterTool,
4E2BExecTool, E2BPythonTool)
5
6llm = LLM(model="anthropic/claude-sonnet-4.6")
7
8list_dir = DirectoryReadTool(directory="./workspace")
9filesystem_tools = [FileReadTool(), FileWriterTool(), list_dir]
10sandbox_tools = [exec_tool, E2BPythonTool()]
11
12@tool("run_tests")
13def run_tests(path: str = "tests/") -> str:
14    """Đồng bộ ./workspace vào sandbox, sau đó chạy pytest ở đó."""
15    return E2BExecTool().run(command=sync_and_test_command(path))
16
17explorer = Agent(role="Codebase Explorer", goal="Lập bản đồ kho, đưa ra các tệp liên quan.",
18    tools=[read_file, list_dir], llm=llm)
19coder = Agent(role="Software Engineer", goal="Thực hiện thay đổi được yêu cầu.",
20    tools=filesystem_tools, reasoning=True, llm=llm)
21tester = Agent(role="Test Runner", goal="Chạy kiểm thử trong sandbox, báo cáo đỗ/trượt.",
22    tools=sandbox_tools + [read_file] + [run_tests], llm=llm)
23manager = Agent(role="Engineering Lead", goal="Ủy quyền các bước, kết thúc khi kiểm thử đỗ.",
24    allow_delegation=True, llm=llm)
25
26task = Task(
27    description="Trong ./workspace, {objective}. Khám phá, chỉnh sửa, kiểm thử, báo cáo.",
28    expected_output="Tóm tắt các thay đổi và kết quả kiểm thử.", human_input=True,
29)
30crew = Crew(
31    agents=[explorer, coder, tester], tasks=[task],
32    manager_agent=manager, process=Process.hierarchical,
33    planning=True, memory=True, checkpoint=True,
34)
35result = crew.kickoff(inputs={"objective": "sửa các kiểm thử bị lỗi trong account.py"})

Các bộ khung tác nhân dễ đánh giá nhất khi thành công có thể được kiểm tra tự động. Một bộ kiểm thử cung cấp cho tác nhân một mục tiêu cụ thể, để nó có thể lập kế hoạch, chỉnh sửa, kiểm thử và lặp lại cho đến khi mọi thứ đều đỗ.

Vì vậy, điều này đã được kiểm tra trên một mã nguồn nhỏ, một lớp BankAccount với hai lỗi thực tế và năm bài kiểm thử, trong đó ba bài bị lỗi. Quy tắc là chỉ sửa phần triển khai, không sửa các bài kiểm thử.

Điều này phản ánh cách Anthropic đánh giá các tác nhân lập trình nội bộ. Một ví dụ được công bố có Claude xây dựng lại một bản sao của giao diện claude.ai dựa trên một bộ kiểm thử lớn bị lỗi.

Ở đây, bộ khung đã đưa dự án từ 3 lỗi và 2 đỗ lên tất cả 5 đỗ, với quy tắc chỉ triển khai đã đóng lối tắt chỉnh sửa hoặc xóa các bài kiểm thử bị lỗi.

Những gì vẫn là công việc của bạn

Một số phần của hệ thống không phải là thứ framework xây dựng cho bạn:

• Các lời nhắc (prompts). Hành vi của mỗi tác nhân đến từ vai trò, mục tiêu và backstory của nó. Việc làm cho chúng đúng đòi hỏi kiểm thử và lặp lại, và không có cờ cấu hình nào thay thế được.
• Môi trường thực thi. Sandbox, dù là E2B hay một máy ảo tự quản lý, phải được thiết lập và kết nối.
• Lựa chọn công cụ. Công cụ nào mỗi tác nhân được cấp, và tác nhân nào nên có quyền truy cập vào cái gì, là một quyết định thiết kế mà framework không đưa ra.

Cũng có một chi phí cho chính bộ khung. Lập kế hoạch, tác nhân phụ và lặp đều thêm các lệnh gọi API, vì vậy một thiết lập tác nhân phức tạp có thể trở nên đắt đỏ hơn một tác vụ mà một lệnh gọi mô hình duy nhất sẽ giải quyết trực tiếp.

Và có một hạn chế dài hạn đáng ghi nhớ. Khi các mô hình cải thiện, một số giàn giáo (scaffolding) không còn cần thiết nữa, bởi vì một số thứ được xây dựng vào bộ khung ngày nay là một giải pháp tạm thời cho các giới hạn của mô hình hiện tại chứ không phải là một yêu cầu vĩnh viễn.

Anthropic ban đầu sử dụng đặt lại ngữ cảnh (context resets) để giữ cho Claude Sonnet 4.5 không kết thúc tác vụ quá sớm, và chúng không còn cần thiết nữa với Claude Opus 4.5 có năng lực hơn.

Kết luận

Đó là toàn bộ phát hiện. Khả năng của một tác nhân lập trình chủ yếu nằm ở bộ khung, và một framework điều phối cung cấp cho bạn nhiều phần của bộ khung đó hơn bạn nghĩ.

Vòng lặp, lập kế hoạch, ủy quyền, sandbox và bộ nhớ đều đến dưới dạng cấu hình, trong khi các lời nhắc, môi trường thực thi và lựa chọn công cụ vẫn là của bạn.

Nếu bạn muốn chạy thử nghiệm này trên mã nguồn của riêng mình, tài liệu CrewAI bao gồm mọi tính năng được sử dụng ở đây và framework hoàn toàn là mã nguồn mở.

Xem Tài liệu CrewAI →

Tìm tất cả mã ở đây →

Cảm ơn bạn đã đọc!

Chúc bạn vui vẻ! :)