Agent = Model + Harness: Đừng mang động cơ F1 lắp vào xe bus không phanh

Hồi cuối năm ngoái, mình có tự chế một con bot chạy ngầm để tự động đọc menu của các đối tác quán ăn gửi về dưới dạng PDF/Excel, rồi parse qua struct Go để nạp vào DB của hệ thống Menu Service.

Logic rất đơn giản: đọc file -> nhét vào prompt -> gọi API GPT-4 -> nhận JSON -> parse vào struct -> save. Mình tự tin chạy thử. 3 ngày đầu chạy ngon lành. Đến ngày thứ 4, một quán gửi cái file PDF thực đơn dài 15 trang, scan mờ căm và cấu trúc lộn xộn.

Kết quả: Con bot rơi vào một vòng lặp vô tận (infinite loop). Model cứ trả về JSON thiếu trường validation, code Go của mình trả về lỗi, rồi prompt lại gọi model bảo “sửa đi”. Model lại sửa nhưng lại sai chỗ khác. Nó lặp đi lặp lại như thế suốt 2 tiếng cho đến khi mình phát hiện ra và kill process. Mở dashboard OpenRouter lên xem: bay sạch gần $40 tiền API chỉ trong một buổi sáng.

Lúc đó mình mới ngộ ra một chân lý: Model xịn đến mấy mà thả rông không có khung kiểm soát (harness) bọc xung quanh, thì sớm muộn gì cũng đốt tiền hoặc phá hoại hệ thống.

Tuần trước, LangChain có đăng một bài blog rất hay tên là “The Anatomy of an Agent Harness”. Nó mổ xẻ chính xác cái “khung kiểm soát” này. Bài viết này là những gì mình đúc kết được sau khi đọc bài đó, liên hệ trực tiếp với những trải nghiệm đau thương của mình khi làm việc với các agent “hot” hiện tại như Hermes Agent, OpenClaw và Pi.

Agent = Model + Harness. Nếu không phải Model, bạn chính là Harness

Có một lầm tưởng cực kỳ phổ biến: Cứ nhét prompt xịn vào một con LLM mạnh (như GPT-4o hay Claude 3.5 Sonnet) là bạn có một AI Agent.

Không phải. Con LLM thô (raw model) thực chất cực kỳ bất lực. Về bản chất, nó chỉ nhận vào một chuỗi token (chữ, ảnh, tiếng nói) và xuất ra một chuỗi token khác. Nó hoàn toàn stateless.

• Nó không biết lưu trữ file tạm.
• Nó không biết cài thư viện hay chạy compiler để test code.
• Nó không biết tự rollback git khi code bị lỗi cú pháp.
• Nó không biết tự động thu gọn bộ nhớ khi cuộc hội thoại quá dài (context rot).

Để biến cái “động cơ sinh chữ” này thành một cỗ máy làm việc thực thụ (work engine), bạn cần một hệ thống bọc xung quanh nó. Hệ thống đó gọi là Harness.

User -> Harness (Sandbox, Filesystem, Memory, Tools) -> Model (LLM) -> Output

Công thức chuẩn là: Agent = Model + Harness.

Nếu bạn đang viết code, cấu hình hệ thống, tạo Docker sandbox, hay viết công cụ để bọc ngoài LLM - bạn chính là người đang làm Harness Engineering.

Đối với anh em backend dev mình, có một cách so sánh cực kỳ dễ hình dung:

• Model giống như một cái http.HandlerFunc trong Go: Nó nhận request (input prompt) và trả về response (completion text). Nó hoàn toàn stateless và chỉ xử lý đúng một nhiệm vụ logic.
• Harness giống như toàn bộ Web Framework & Infrastructure bọc ngoài: Nó bao gồm Gin router để định tuyến, middleware để check Auth, database connection pool, logger ghi trace, Docker container chạy cô lập, rate limiter để tránh bị spam, và systemd để tự restart khi crash.

Bạn không thể quăng một cái handler trần trụi lên production mà không có framework bọc ngoài. Agent cũng vậy.

Mổ xẻ 5 bộ phận cấu thành một Harness thực chiến

Một Agent Harness hiện đại không chỉ là một cái script Python gọi API đơn thuần. Để chạy được các task phức tạp trên codebase thực tế (như Claude Code hay Hermes Agent đang làm), Harness phải có các thành phần sau:

1. Filesystem & Git (Hạ tầng lưu trữ)

Model chỉ có thể thao tác trên những gì nằm trong context window của nó. Nhưng context window thì đắt và dễ bị trôi. Filesystem chính là “RAM vật lý” để agent lưu trữ spec, ghi lại nhật ký công việc (journal) hoặc lưu các file code trung gian.

Khi kết hợp với Git, filesystem trở thành một cỗ máy thời gian. Nếu agent lỡ tay viết code ngu phá hỏng project (điều xảy ra như cơm bữa), Harness có thể tự động chạy git checkout -- . để khôi phục trạng thái cũ.

2. Sandbox & Verification Loop (Môi trường chạy và tự sửa lỗi)

Để agent tự viết code và tự chạy thử, nó cần một sandbox (thường là Docker container hoặc VM cô lập). Chạy code của AI trên máy thật mà không có sandbox là cách nhanh nhất để bay màu data.

Harness sẽ cung cấp cho agent các tool như Bash, compiler (Go, Node), và quan trọng nhất là các Verification Tools (như test runner, linter). Khi agent sửa code, Harness sẽ tự động kích hoạt go test ./... hay staticcheck. Nếu test fail, Harness gửi trả lỗi về cho model để nó tự debug. Đây gọi là vòng lặp tự sửa lỗi (self-verification loop) - thứ tạo nên sự khác biệt giữa một agent tự động và một con chatbot thông thường.

3. Kiểm soát suy giảm bộ nhớ (Battling Context Rot)

Khi agent làm việc lâu trong một session, context window sẽ đầy lên. Hiện tượng này gọi là Context Rot: model bắt đầu “lú”, quên spec ban đầu, lặp lại các lỗi cũ, và suy giảm khả năng suy luận.

Harness xịn sẽ giải quyết việc này bằng 3 cơ chế:

• Compaction (Thu gọn): Tự động gom các message cũ lại, tóm tắt chúng và giải phóng context trống.
• Tool Output Offloading (Trích xuất đầu ra): Nếu agent chạy một lệnh bash trả về 10,000 dòng log, Harness sẽ tự động cắt ngắn (truncate) phần giữa, ghi file log đầy đủ ra đĩa, và chỉ nạp head/tail vào context của model kèm đường dẫn file để model tự đọc nếu cần.
• Skills (Lazy Loading Tools): Thay vì nạp mô tả của 100 tools vào prompt từ đầu session (làm loãng context), Harness chỉ hiển thị một danh sách tóm tắt (progressive disclosure). Khi model thực sự cần dùng một skill cụ thể, Harness mới nạp chi tiết công cụ đó vào.

4. Vòng lặp Ralph Loops (Long-Horizon Execution)

Khi làm các task lớn kéo dài vài tiếng, model thường có xu hướng “tự mãn” và dừng lại sớm (early stopping) khi mới làm được một nửa.

Harness sẽ áp dụng pattern gọi là Ralph Loop: chặn tín hiệu exit của model, kiểm tra trạng thái mục tiêu trong filesystem, và nếu chưa hoàn thành, nó sẽ “đá đít” model bằng cách xóa sạch context cũ (cho nhẹ đầu) rồi inject một prompt mới: “Đây là trạng thái hiện tại trên disk, bạn mới làm được 50% task, hãy tiếp tục.”

3 Ví dụ điển hình về Harness: Hermes Agent, OpenClaw và Pi

Để dễ hình dung, chúng ta hãy đặt 3 cái tên đang rất hot lên bàn cân để xem chúng đóng vai trò gì trong bức tranh Harness này.

+-------------------------------------------------------------+
|                      HUMAN INTERFACE                        |
|   (Zalo, Telegram, Discord, WebUI - Managed by OpenClaw)    |
+-------------------------------------------------------------+
                              | (Message routing & auth)
                              v
+-------------------------------------------------------------+
|                       AGENT HARNESS                         |
|   (Context, Sandbox, Memory, Tools - Managed by Hermes/Pi)  |
+-------------------------------------------------------------+
                              | (Structured completion API)
                              v
+-------------------------------------------------------------+
|                        RAW MODEL                            |
|             (Claude 3.7, GPT-5 - Stateless LLM)             |
+-------------------------------------------------------------+

1. Hermes Agent: Internal Harness & Sandbox Operator

Hermes chính là một con quái vật về mặt Harness Engineering mà mình đang dùng để viết chính bài viết này.

• Cách nó quản lý Context: Khi mình gọi các tool chạy terminal có output siêu dài, Hermes không nhồi hết đống text đó vào chat. Nó tự lưu ra file log cục bộ dưới dạng cache và chỉ show bản preview.
• Cách nó quản lý Skill: Thay vì nhét tất cả tool vào system prompt, Hermes có hệ thống skill_manage và skill_view. Khi cần viết blog, nó mới load skill blog-writer-v2 vào context.
• Cách nó quản lý Memory: Nó dùng một database SQLite cục bộ (session_search) chạy FTS5 để lưu trữ lịch sử các phiên làm việc trước. Khi mình hỏi “tuần trước mình tối ưu cấu trúc menu service thế nào nhỉ?”, nó sẽ tự query database để lấy context thay vì bắt mình copy-paste lại.

2. OpenClaw: External Harness & Messaging Gateway

Nếu Hermes là bộ xương và cơ bắp chạy bên trong sandbox, thì OpenClaw là lớp da và hệ thần kinh kết nối với thế giới bên ngoài.

• Định tuyến (Multi-agent routing): OpenClaw hoạt động như một gateway tự host (self-hosted gateway). Nó kết nối các ứng dụng chat như Telegram, Zalo, Discord với các coding agents chạy ngầm.
• Quản lý phiên (Session & Workspace Isolation): Khi bạn nhắn tin cho bot qua Zalo, OpenClaw sẽ nhận diện chat ID của bạn, ánh xạ nó vào một thư mục workspace biệt lập trên VPS, khôi phục session tương ứng của Hermes Agent, và chuyển tiếp tin nhắn. Nó đảm bảo các cuộc hội thoại từ các group chat khác nhau không bị lẫn lộn dữ liệu.
• Bảo mật: OpenClaw đóng vai trò là “chốt chặn” an toàn. Nó không cho phép các lệnh terminal thô (raw CLI execution) bắn thẳng ra Zalo/Telegram của khách hàng, tránh việc lộ API key hay cấu trúc folder nhạy cảm.

3. Pi (pi-agent-harness): Minimalist Terminal Harness

Trái ngược với sự đồ sộ của Hermes hay tính năng gateway của OpenClaw, Pi là một dự án harness tối giản bằng TypeScript chạy hoàn toàn trên terminal.

• Triết lý của Pi là giữ cho core cực kỳ nhỏ gọn. Nó chỉ cung cấp một khung sườn (skeleton) để lập trình viên tự định nghĩa skill, viết prompt template và setup workspace.
• Pi cực kỳ thích hợp cho các task tự động hóa nhanh, nhẹ trên local máy tính cá nhân mà không cần dựng lên cả một hệ thống sandbox phức tạp hay gateway đa kênh.

Tương lai: Khi Model và Harness hòa làm một

Hiện tại, các nhà phát triển AI đang huấn luyện model theo kiểu huấn luyện kèm theo Harness (harness-in-the-loop).

Con model Claude 3.7 hay GPT-5 mới nhất không phải tự dưng mà biết cách viết patch file hay sử dụng lệnh terminal. Chúng được post-train trong các môi trường giả lập có sẵn các tool của Claude Code hay OpenAI Codex. Điều này giúp model phối hợp với các tool trong harness cực kỳ mượt mà.

Nhưng nó cũng dẫn tới một side-effect: model bị overfitting vào cấu trúc công cụ của hãng đó. Ví dụ, nếu bạn đổi định dạng tool chỉnh sửa file của OpenAI Codex từ dạng apply_patch truyền thống sang một cấu trúc khác, hiệu năng của model có thể tụt thảm hại vì nó không quen.

Tuy nhiên, bảng xếp hạng Terminal Bench 2.0 (nơi benchmark khả năng tự sửa lỗi và chạy terminal của các agent) đã chỉ ra một sự thật thú vị: Cùng một model (ví dụ Claude 3.5 Opus), nhưng khi chạy trên các harness được tối ưu hóa khác nhau, điểm số có thể chênh lệch từ vị trí Top 30 vọt lên Top 5.

Điều này có nghĩa là: Model chỉ là điều kiện cần. Harness mới là điều kiện đủ để bạn tối ưu hóa hiệu năng và chi phí của Agent cho bài toán của riêng mình.

Bottom line: Đừng đổ lỗi cho Model

Lần tới, nếu con AI agent của bạn viết code sai convention, rơi vào loop vô hạn, hay làm tràn context dẫn đến crash hệ thống, đừng vội chửi con LLM ngu hay vội vã đổi sang model đắt tiền hơn.

Hãy dừng lại và tự hỏi: Mình đã build cho nó một cái Harness đủ tốt chưa?

Bạn đã cấu hình sandbox an toàn chưa? Đã có linter tự động chặn code lỗi chưa? Đã có cơ chế truncate log để chống context rot chưa? Đã lưu trữ spec dự án vào các file markdown cục bộ làm guideline cho nó chưa?

Nếu chưa, hãy bắt tay vào làm Harness Engineering đi thôi. Động cơ F1 rất mạnh, nhưng nó cần một khung gầm chắc chắn và bộ phanh an toàn để có thể cán đích.

Còn bạn thì sao? Bạn đang tự build harness cho con bot của mình bằng script riêng, hay đang dùng các giải pháp có sẵn như Hermes Agent, OpenClaw, và Pi? Chia sẻ trải nghiệm của bạn ở phần bình luận nhé! 🦞