AI Digest · bản ngày · v2 (đào sâu)

Agent tự dựng lấy bộ khung của mình — benchmark đầu tiên chấm điểm, và điểm không đẹp

Ngày: 04/09/2026 Cửa sổ 03–04/09 Thu 60 bài Lướt ~5 phút Đọc sâu ~18 phút
Hôm nay trong 30 giây
Mạch chính

Có một câu hỏi ngầm chạy qua cả bốn paper hôm nay: khi agent tự cải thiện chính mình, nó nên tự sửa cái gì? Có ba thứ để sửa — trọng số (train lại), harness (code bao quanh model: vòng lặp, tool, bộ nhớ, luật dừng), và kỹ năng (kiến thức thao tác viết thành văn bản, nạp vào context khi cần).

Bằng chứng hôm nay xếp ba thứ đó theo thứ tự rõ ràng. Sửa kỹ năng ăn nhất và chuyển giao tốt nhất: Repo-To-Skill được +134,3% trên MLE-bench mà không đụng một tham số nào. Sửa harness thì ăn thật nhưng bấp bênh: HarnessDev đo được cả trường hợp thắng người lẫn thua người, và phần tiến hoá gắn chặt với đúng model đang chạy nó nên không mang đi nơi khác được. Sửa trọng số từ chính kinh nghiệm của mình là rủi ro nhất: S3Gym thấy negative transfer nặng.

Nghĩa là chiến lược thực dụng cho một người xây agent hôm nay gần như ngược với trực giác: đừng vội để agent tự viết lại vòng lặp của nó, và càng đừng vội train nó trên log của chính nó. Hãy đổ công vào việc biến những gì đã biết thành kỹ năng đọc được, kiểm chứng được. Đó là chỗ duy nhất trong ba chỗ mà cải thiện không bốc hơi khi đổi model.

Papers (4 feature, đều chưa xuất hiện trong digest nào trước đó)

agenticHarnessDev: Can LLMs Create and Evolve Their Own Agent Harness?

BLUF: Benchmark đầu tiên bắt model tự dựng tự tiến hoá harness của chính nó, đo trên 2.207 ca thật — kết luận: agent tự viết hạ tầng cho mình chưa thay được người ở code/search/research, và cái nó tự cải thiện được thì không mang sang model khác.
30 giây
  • Hai pha: Creation — dựng cả hệ thống thực thi từ một seed tối thiểu + vài ca mẫu; Evolution — lặp lại việc tự sửa harness dựa trên phản hồi từ lần chạy trước.
  • Quy mô: 6 model tạo lập, 4 lĩnh vực, 5 benchmark hạ nguồn, 2.207 instance, có tập task giấu kín không cho thấy khi phát triển. Chấm cả năng lực lẫn chi phí token.
  • Kết quả chia đôi: thua tham chiếu người viết ở code, search, research; hoà hoặc vượt ở viết láchchạy thí nghiệm ML.
  • Điểm đau: lợi ích từ Evolution không ổn định và chỉ chuyển một phần sang task giữ kín; mức tăng phụ thuộc nặng vào đúng model nào đang thực thi harness đó.
HarnessDev — benchmark cho việc model tự tạo và tự tiến hoá harness (ảnh: trang paper trên Hugging Face)
HarnessDev — benchmark cho việc model tự tạo và tự tiến hoá harness (ảnh: trang paper trên Hugging Face)
Đọc sâu ~3 phút

Bối cảnh. Gần như mọi so sánh model hiện nay đều ngầm giữ harness cố định: cùng một vòng lặp agent, cùng bộ tool, chỉ thay model rồi xem điểm. Nhưng thực tế ai từng xây agent đều biết harness quyết định điểm số không kém model — digest hôm qua có Harness-of-Harness nâng Codex từ 49,58 lên 71,52 chỉ bằng cách bọc thêm một vòng lặp bên ngoài. Câu hỏi tự nhiên tiếp theo: nếu harness quan trọng đến thế, model có tự viết được harness cho chính nó không? HarnessDev là nỗ lực đầu tiên biến câu hỏi đó thành một phép đo có kiểm soát thay vì một giai thoại.

Cách làm, từng bước. Bước 1 — mỗi model tạo lập nhận một "seed" tối thiểu (khung sườn trần trụi, chưa có logic điều phối) cùng một tập nhỏ ca ví dụ, rồi phải tự viết ra toàn bộ hệ thống thực thi: vòng lặp, cách gọi tool, cách giữ trạng thái, luật dừng. Bước 2 — harness vừa dựng được đem chạy trên benchmark hạ nguồn, và model nhận lại phản hồi từ chính lần chạy đó. Bước 3 — model sửa harness của mình, chạy lại, lặp. Bước 4 — bản cuối cùng bị đem ra chấm trên tập task giấu kín, tức những ca chưa từng xuất hiện trong quá trình phát triển. Đây là chi tiết quan trọng nhất của thiết kế: nó tách bạch "harness thật sự tốt hơn" khỏi "harness được vá vừa khít với đúng những ca đã thấy".

Quy mô đo6 model tạo lập · 4 lĩnh vực · 5 benchmark · 2.207 instance
Thua người viếtcode, search, research
Hoà / thắng người viếtviết lách, chạy thí nghiệm ML
Hai trục chấmnăng lực (điểm trên task giữ kín) + hiệu quả (token thực thi)
Tiến hoácó tăng, nhưng không ổn định, chuyển giao chỉ một phần
Ràng buộc modelmức tăng phụ thuộc nặng vào model đang chạy harness

Vì sao kết quả chia đôi theo lĩnh vực. Cách đọc hợp lý nhất: viết lách và chạy thí nghiệm ML là những việc mà bản thân model đã biết quy trình — nó chỉ cần viết ra thành code điều phối. Còn code, search và research là những việc mà harness tốt chứa đầy tri thức cay đắng tích luỹ từ thất bại thật: retry thế nào, khi nào cắt context, tool nào hay trả rác, lỗi nào đáng bỏ qua và lỗi nào phải dừng. Loại tri thức đó không suy ra được từ một seed và vài ví dụ; nó phải trả giá mới có.

Hạn chế. Chính paper nói rõ phần yếu nhất là Evolution: mức tăng bấp bênh và chỉ chuyển được một phần sang task giữ kín — nghĩa là một phần đáng kể của cái gọi là "tự cải thiện" thực chất là overfit vào tập phát triển. Thêm nữa, việc mức tăng bám vào model thực thi có nghĩa harness sinh ra không phải một tài sản độc lập: đổi model là mất. Bản tóm tắt cũng không nêu con số tuyệt đối theo từng lĩnh vực, nên hiện chỉ đọc được chiều hướng, chưa đọc được biên độ.

Ý nghĩa cho bạn. Nếu bạn đang cân nhắc để agent tự viết lại vòng lặp của chính nó, đây là bằng chứng nên hoãn — ít nhất với việc code. Ngược lại, có một cách dùng kết quả này rất thực dụng: HarnessDev cho thấy harness là thứ đáng phiên bản hoá và đo riêng, chứ không phải phần phụ tuỳ tiện quanh model. Hãy đối xử với harness của bạn như code sản phẩm — có test, có tập giữ kín, có so sánh trước/sau — thay vì chỉnh tay rồi tin cảm giác. Và khi bạn đọc bất kỳ tuyên bố "model X mạnh hơn model Y" nào, hãy hỏi harness nào đang chạy: paper này vừa đo được rằng câu trả lời đó đổi kết quả.

🔬 Yêu cầu deep-dive paper này

agenticRepo-To-Skill: Distilling GitHub Repositories Into AI4AI Skills

BLUF: Nén 1.000 repo ML thành hơn 5.000 skill đã kiểm chứng rồi cho agent nạp khi cần — cùng model, cùng ngân sách tính toán, MLE-bench tăng 134,3% so với chính agent đó khi không có skill.
30 giây
  • Vấn đề: tri thức thao tác (biết làm thế nào) nằm trong repo và paper — quá lớn để nạp vào context lúc chạy, nên thực tế nó nằm ngoài agent.
  • Hai hướng chưng cất: task-agnostic — nén repo phổ biến thành skill dùng lại được cho cả lĩnh vực; task-oriented — sinh skill cho đúng một bài toán nghiên cứu cụ thể.
  • Sản phẩm: AREX-Skill Library5.000+ skill đã kiểm chứng từ 1.000 repo, sắp theo 20 lĩnh vực và 178 họ năng lực. Agent dùng nó tên là DisCo.
  • Số liệu (backbone GPT-5.5, ngân sách tính toán cố định, so với chính agent đó không có skill): MLE-bench +134,3%, PaperBench +34,4%, PassNet +14,0%, FrontierCS +9,2%.
Repo-To-Skill — chưng cất repo thành thư viện skill AREX (ảnh: trang paper trên Hugging Face)
Repo-To-Skill — chưng cất repo thành thư viện skill AREX (ảnh: trang paper trên Hugging Face)
Đọc sâu ~3 phút

Bối cảnh. Một agent nghiên cứu ML giỏi cần biết những thứ rất cụ thể: thư viện nào dùng cho loại dữ liệu nào, hyperparameter nào thường sống được, lỗi nào là do phiên bản. Toàn bộ tri thức đó đã tồn tại — trong hàng nghìn repo GitHub. Nhưng repo là thứ hàng trăm nghìn dòng, không thể nạp vào context lúc agent đang chạy. Đây chính là điểm nghẽn mà paper gọi tên: kiến thức thao tác nằm ngoài agent, và mỗi lần chạy agent lại phải mò lại từ đầu.

Cách làm, từng bước. Bước 1 — chọn 1.000 repo ML được dùng rộng rãi. Bước 2 — chưng cất mỗi repo thành các "skill": mô tả ngắn, đọc được, đủ để nạp vào context, ghi lại cách làm chứ không phải toàn bộ mã. Bước 3kiểm chứng từng skill (đây là chỗ phân biệt thư viện này với một đống tóm tắt tự sinh: paper nhấn mạnh "verified"). Bước 4 — sắp xếp thành 20 lĩnh vực và 178 họ năng lực, để lúc chạy agent tra được đúng nhánh cần thay vì quét cả kho. Bước 5 — song song, sinh thêm skill theo hướng task-oriented cho từng bài toán cụ thể. Agent DisCo lúc làm việc sẽ kéo skill phù hợp vào context.

Thư viện5.000+ skill · 1.000 repo · 20 lĩnh vực · 178 họ năng lực
MLE-bench+134,3%
PaperBench+34,4%
PassNet+14,0%
FrontierCS+9,2%
Điều kiện so sánhcùng backbone GPT-5.5, ngân sách tính toán cố định, đối chứng là chính agent đó không có skill

Vì sao con số MLE-bench lớn bất thường. Chú ý biên độ chênh nhau rất xa giữa các benchmark: +134,3% ở MLE-bench nhưng chỉ +9,2% ở FrontierCS. Cách đọc hợp lý: MLE-bench là loại việc mà phần lớn công sức nằm ở quy trình đã có người làm rồi — dựng pipeline, chọn baseline, tránh bẫy quen thuộc. Đó đúng là thứ chưng cất từ repo được. FrontierCS thiên về suy luận mới, nơi không có repo nào chứa sẵn đáp án. Nói cách khác, skill không làm model thông minh hơn; nó xoá đi phần công việc mà loài người đã giải xong và viết lại được.

Hạn chế. Bản tóm tắt chỉ nêu một hạn chế cốt lõi (tri thức thao tác nằm ngoài agent) mà không nêu giới hạn của chính phương pháp — đó là điểm trừ về báo cáo. Ba câu hỏi tự nhiên chưa có câu trả lời: skill hỏng khi thư viện lên phiên bản mới thì phát hiện bằng cách nào; "verified" được kiểm ở mức nào (chạy được, hay ra đúng kết quả); và con số phần trăm tương đối luôn phóng đại khi baseline thấp — cần biết điểm tuyệt đối mới đọc đúng được.

Ý nghĩa cho bạn. Đặt cạnh HarnessDev ở trên, hai paper này tạo thành một lời khuyên khá dứt khoát: đầu tư vào thư viện skill, đừng đầu tư vào việc agent tự viết harness. Skill là văn bản — bạn đọc được, sửa được, review được, và nó không dính vào một model cụ thể. Cụ thể với repo của bạn: mỗi lần bạn phải giải thích lại cho agent một quy ước nội bộ (cách chạy test, cách deploy, cái bẫy đã gặp), đó chính là một skill nên được viết ra một lần và kiểm chứng, thay vì lặp lại trong prompt. Lưu ý an toàn đã nêu trong digest 31/08: thư viện skill vừa là đòn bẩy vừa là bề mặt tấn công — skill là thứ agent tin tưởng thực thi, nên nguồn gốc của nó phải được kiểm soát.

🔬 Yêu cầu deep-dive paper này

evalsS3Gym: Can LLMs Turn Self-Testing and Self-Judging into Self-Improvement?

BLUF: Tách "tự test", "tự chấm" và "tự giỏi lên" thành ba năng lực đo riêng trên 7 môi trường có verifier chạy được — và cho thấy mắt xích gãy nằm ở bước cuối: nhận ra hành động đúng không tự động biến thành chính sách dùng lại được.
30 giây
  • Thiết kế: tách bạch hành vi thăm dò (agent tự chơi, tự thử) khỏi phần đánh giá giữ kín — nên không thể ăn gian bằng cách nhớ đáp án.
  • Ba đường nạp kinh nghiệm được so trực tiếp: (1) nhét thẳng lịch sử vào context, (2) bộ nhớ tóm tắt có gắn điểm, (3) train tham số.
  • Kết luận chính: tự cải thiện không tự động và không đồng đều. Tóm tắt thắng khi kinh nghiệm nén được thành luật dùng lại; lịch sử thô thắng khi cần thông tin chính xác phụ thuộc trạng thái.
  • Cảnh báo: train tham số cho kết quả bất nhất — có task tăng, có task negative transfer nặng.
S3Gym — tách self-testing, self-judging và self-improvement thành ba phép đo (ảnh: trang paper trên Hugging Face)
S3Gym — tách self-testing, self-judging và self-improvement thành ba phép đo (ảnh: trang paper trên Hugging Face)
Đọc sâu ~3 phút

Bối cảnh. "Agent tự cải thiện" thường được nói như một năng lực duy nhất. Thực ra nó là một chuỗi ba bước, và chuỗi đứt ở đâu cũng ra cùng một triệu chứng: agent chạy nhiều vòng mà không khá lên. Bước một, agent phải tự sinh ra phép thử có ý nghĩa cho chính mình. Bước hai, nó phải chấm đúng kết quả của phép thử đó. Bước ba — và đây là bước ít ai đo — nó phải biến kết luận thành hành vi khác đi ở lần sau. S3Gym là nỗ lực tách ba bước để biết bước nào đang hỏng.

Cách làm, từng bước. Bước 1 — dựng 7 game dạng văn bản, mỗi game có verifier chạy được, tức máy chấm đúng/sai một cách khách quan chứ không nhờ một model khác chấm. Bước 2 — cho agent một pha thăm dò tự do: tự thử, tự quan sát, tự chấm. Bước 3 — tách hẳn một tập đánh giá giữ kín; điểm cuối cùng chỉ tính trên tập này. Bước 4 — so ba cách chuyển kinh nghiệm từ pha thăm dò sang pha đánh giá: nhét thẳng lịch sử tương tác vào context; nén thành bản tóm tắt có gắn điểm số; hoặc train thẳng vào tham số. Vì cả ba dùng chung một pha thăm dò, khác biệt về điểm phản ánh đúng chất lượng của cách nhớ, không phải chất lượng của trải nghiệm.

Môi trường7 game văn bản, mỗi game có verifier thực thi được
Đường 1 — lịch sử thôthắng khi cần thông tin chính xác, phụ thuộc trạng thái
Đường 2 — tóm tắt gắn điểmthắng khi kinh nghiệm nén được thành luật dùng lại
Đường 3 — train tham sốbất nhất: có task tăng, có task negative transfer nặng
Kết luậnself-improvement không tự động, không đồng đều; nút thắt là biến phản hồi thành chính sách thực thi được và chuyển giao được

Vì sao không có đường nào thắng tuyệt đối. Đây là kết quả có cấu trúc chứ không phải nhiễu. Tóm tắt là một phép nén có mất mát: nó giữ lại quy luật và vứt đi chi tiết. Khi bài toán thật sự có quy luật — "cửa luôn khoá cho đến khi lấy được chìa" — nén là lợi. Khi bài toán đòi chi tiết phụ thuộc trạng thái — "phòng số 7 có cái bẫy này" — nén chính là chỗ mất thông tin quyết định, và lịch sử thô thắng. Điều này dự đoán được ngay từ bản chất nhiệm vụ, nghĩa là lựa chọn cơ chế nhớ nên là một quyết định thiết kế có cân nhắc, không phải mặc định.

Hạn chế. Bảy game văn bản là môi trường sạch, có verifier khách quan — đúng cái làm phép đo tin được, và cũng đúng cái khiến khó suy ra công việc thật, nơi tín hiệu đúng/sai thường mơ hồ và trễ. Bản tóm tắt không nêu số tuyệt đối nên biên độ của negative transfer chưa đọc được. Ngoài ra, việc pha thăm dò do chính agent điều khiển khiến chất lượng kinh nghiệm gắn với năng lực tự test của model — một biến bị trộn vào mà thiết kế chưa tách hết.

Ý nghĩa cho bạn. Đây là paper nói thẳng vào giả định phổ biến nhất trong các vòng lặp agent: "cứ cho nó chạy nhiều lần rồi nó tự khá lên". Kết quả nói ngược lại — trừ khi bạn thiết kế cụ thể kinh nghiệm được nhớ ở dạng gì. Việc nên làm hôm nay: nhìn lại vòng lặp agent của bạn và trả lời hai câu. Thứ nhất, sau mỗi lần chạy, cái gì được giữ lại — transcript thô hay một luật viết ra thành lời? Thứ hai, luật đó có thực thi được không, tức lần sau agent có làm khác đi thật không, hay nó chỉ đọc rồi bỏ qua. Và một cảnh báo cụ thể: nếu bạn định fine-tune trên log của chính agent, hãy giữ một tập task tách biệt để bắt negative transfer — paper này vừa cho thấy nó xảy ra và xảy ra nặng.

🔬 Yêu cầu deep-dive paper này

evalsEarlyEval: Cheaper Agent Evaluation via Early Outcome Prediction

BLUF: Đoán sớm agent sẽ pass hay fail rồi dừng ngay, thay vì chạy hết task — cắt 13–26% số bước và tới 44,1% input token trên SWE-bench Verified, TerminalBench và Toolathlon, đổi lại resolve rate lệch trung bình 1–2 điểm.
30 giây
  • Cơ chế: hai bộ phân loại LightGBM chạy song song — một dự đoán "sẽ thành công", một dự đoán "sẽ thất bại". Bên nào đạt ngưỡng tin cậy đã hiệu chỉnh trước thì dừng chạy.
  • Đầu vào: đặc trưng hành vi (agent đang làm gì), đặc trưng văn bản, và đặc trưng từ lời giải tham chiếu.
  • Tiết kiệm: bỏ 13–26% số bước; giảm tới 44,1% input token và 29,4% output token.
  • Giá phải trả: độ chính xác dự đoán 89–97%; resolve rate từng agent lệch trung bình 1–2 điểm phần trăm.
EarlyEval — dự đoán sớm kết cục để cắt ngắn vòng chấm agent (ảnh: trang paper trên Hugging Face)
EarlyEval — dự đoán sớm kết cục để cắt ngắn vòng chấm agent (ảnh: trang paper trên Hugging Face)
Đọc sâu ~3 phút

Bối cảnh. Chấm agent đắt theo một cách mà chấm model thường thì không. Một câu hỏi trắc nghiệm tốn một lần gọi model; một task SWE-bench tốn hàng chục vòng đọc file, chạy test, sửa, chạy lại. Và phần lớn chi phí đó bị đốt vào những lần chạy mà kết cục đã rõ từ sớm: agent đi sai hướng ngay từ phút đầu rồi vùng vẫy thêm ba mươi bước nữa trước khi hết ngân sách. EarlyEval khai thác đúng chỗ dư thừa đó.

Cách làm, từng bước. Bước 1 — trích đặc trưng từ trạng thái đang chạy của agent: hành vi (đang gọi tool gì, lặp lại bao nhiêu, có tiến triển không), văn bản (nội dung agent sinh ra), và đối chiếu với lời giải tham chiếu. Bước 2 — train hai bộ phân loại LightGBM riêng biệt thay vì một: một chuyên bắt tín hiệu "chắc chắn xong được", một chuyên bắt "chắc chắn hỏng". Tách đôi như vậy cho phép đặt ngưỡng khác nhau cho hai hướng, vì hai loại sai lầm có giá khác nhau. Bước 3hiệu chỉnh ngưỡng: chỉ dừng khi độ tin cậy vượt mức đã calibrate. Bước 4 — khi một trong hai bên vượt ngưỡng, huỷ các bước còn lại và ghi nhận kết cục dự đoán. Ba benchmark được đo: SWE-bench Verified, TerminalBench, Toolathlon.

Bước cắt được13–26%
Input token giảmtới 44,1%
Output token giảmtới 29,4%
Độ chính xác dự đoán89–97%
Sai lệch resolve ratetrung bình 1–2 điểm phần trăm mỗi agent
BenchmarkSWE-bench Verified · TerminalBench · Toolathlon

Chỗ cần đọc kỹ. Chênh lệch giữa "cắt 13–26% số bước" và "giảm tới 44,1% input token" không mâu thuẫn — nó cho biết các bước bị cắt là những bước đắt nhất. Điều này hợp lý về mặt cơ chế: context của agent phình theo thời gian, nên bước thứ 40 tốn nhiều token đầu vào hơn hẳn bước thứ 5. Nói cách khác, phần bị cắt đúng là phần đuôi đắt đỏ, và đó là lý do tỷ lệ tiết kiệm token cao gấp đôi tỷ lệ tiết kiệm bước.

Hạn chế. Sai lệch 1–2 điểm phần trăm nghe nhỏ, nhưng phải đặt cạnh khoảng cách thật giữa các model đang được so: rất nhiều bảng xếp hạng agent hiện nay có các vị trí liền kề cách nhau đúng 1–2 điểm. Nghĩa là EarlyEval an toàn cho vòng lặp phát triển nội bộ, và không an toàn để công bố một bảng xếp hạng. Ngoài ra việc dùng đặc trưng từ lời giải tham chiếu giới hạn phương pháp ở những benchmark có sẵn đáp án — không dùng được để giám sát agent chạy trên việc thật. Và ngưỡng phải hiệu chỉnh lại cho từng phân bố agent/benchmark mới, tức có chi phí thiết lập không nhỏ.

Ý nghĩa cho bạn. Nếu bạn chạy suite eval agent thường xuyên, đây là cách rút ngắn vòng phản hồi mà không phải giảm số task — thứ vốn là đánh đổi khó chịu nhất khi eval tốn tiền. Cách dùng đúng: bật EarlyEval cho các lần chạy trong ngày để lặp nhanh, rồi tắt nó khi chạy bản chốt mà bạn định trích số liệu ra ngoài. Và ngay cả khi bạn không triển khai phương pháp này, phần đo lường của nó đã hữu ích: nó chứng minh một phần tư số bước trong eval agent hiện nay là dư thừa — kết cục đã có thể biết trước rồi.

🔬 Yêu cầu deep-dive paper này

Tin đáng biết

Ghi chú vận hành