7 thg 4, 2026

Cùng Một Model. Chênh Lệch 6x Hiệu Năng. Harness Mới Là Tất Cả.

Tại sao bước nhảy vọt lớn nhất về khả năng AI không nằm ở model tốt hơn — mà ở harness engineering xuất sắc. Phân tích chuyên sâu bài báo Stanford Meta-Harness và ý nghĩa thực tiễn cho mọi developer năm 2026.

Kỹ thuật

Thẻ (5)

# harness # agents # ai-systems # context-engineering # stanford

Bạn dành ba tiếng để chỉnh lại system prompt. Agent vẫn fail. Rồi đồng nghiệp thay một function quản lý context — không đổi model, không sửa prompt — và độ chính xác nhảy 40 phần trăm.

Đó không phải bug. Đó là harness engineering.

Ngành AI năm nay đã chấp nhận một sự thật khó chịu: một language model, dù thông minh đến đâu, cũng không phải là sản phẩm. Nó là một bộ xử lý. Và giống mọi bộ xử lý, nó cần hệ điều hành. Đội Codex của OpenAI chứng minh điều này một cách ngoạn mục — ba kỹ sư xây dựng codebase một triệu dòng không phải bằng cách tự viết code, mà bằng cách thiết kế harness cho coding agent làm việc đó một cách đáng tin cậy.

Ba kỹ sư. Một triệu dòng. Model không thông minh hơn — harness tốt hơn.

Harness là gì, chính xác?

Nói cho rõ: harness là đoạn code quyết định thông tin nào LLM nhìn thấy ở mỗi bước — cái gì lưu vào bộ nhớ, cái gì lấy ra, context nào hiển thị, tool nào cho phép, và khi nào thì dừng.

So sánh thế này cho dễ hình dung:

• Model là CPU — sức mạnh xử lý thô.
• Context window là RAM — bộ nhớ tạm, dung lượng giới hạn.
• Harness là hệ điều hành — quản lý tài nguyên, lên lịch task, ngăn crash.
• Agent là ứng dụng — business logic cụ thể chạy trên nền tảng đó.

Thay harness quanh một model cố định, bạn tạo ra khoảng chênh lệch hiệu năng gấp 6 lần trên cùng benchmark. Paper chứng minh bằng số liệu thực tế.

Cấu trúc của một production harness

Một harness vững chắc có bốn lớp. Thiếu lớp nào cũng biến agent thành demo chạy một lần, ngày sau hallucination.

Quản lý context và memory

LLM bắt đầu mỗi phiên với chứng mất trí toàn phần. Harness tốt duy trì state qua các task dài, bơm context liên quan, và offload data cũ trước khi context window trở thành bãi rác ồn ào.

# Đừng nhồi nhét cả đoạn hội thoại vào context.
# Model sẽ chết đuối trong chính lời nói của nó.
def prune_context(history, max_tokens=8000):
    # Giữ lại plan, cắt bỏ chatter
    return keep_intent(history)  # Không phải history[-N], không phải tất cả

Thực thi tool và sandboxing

Model cần tương tác thế giới thực. Nhưng cấp quyền API không giới hạn là một security incident đang chờ xảy ra. Harness định nghĩa ranh giới, thực thi progressive disclosure của skills, và xác thực mọi tool call trước khi chạy.

Orchestration và deterministic middleware

Harness triển khai lifecycle hooks. Quản lý sub-agent handoffs, thực thi custom linters, kích hoạt compaction routines, và bắt model trước khi nó rơi vào vòng lặp hallucination.

Evaluation và observability

Không đo thì không cải thiện được. Harness nghiêm túc chấm điểm toàn bộ hành trình của agent — chất lượng reasoning, hiệu quả chọn tool — chứ không chỉ kết quả cuối cùng. Vì bước hai fail âm thầm thì bước năm thừa hưởng state đã hỏng.

Điểm bể: harness engineering thủ công đã bất lực

Đây là bài toán tất cả chúng ta đối mặt. Trong demo có kiểm soát, agent của bạn thực hiện task năm bước hoàn hảo. Trong production — nơi task kéo dài nhiều ngày, hàng trăm tool call, và dependency leo thang — agent mất phương hướng. Nó quên hướng dẫn. Nó hallucinate tham số API không tồn tại.

Phản xạ đầu tiên của một engineer: tweak prompt. Viết thêm system instruction. Nhồi thêm few-shot examples.

Nhưng đó là điều trị bệnh hạ tầng bằng miếng băng cá nhân.

Cái cần là tối ưu harness — tinh chỉnh hệ thống code quanh model để cải thiện toàn bộ hệ thống. Và cho đến gần đây, quá trình này hoàn toàn thủ công.

Đến lúc Stanford xuất hiện.

Stanford Meta-Harness: paper thay đổi cuộc chơi

Tháng 3 năm 2026, một nhóm nghiên cứu từ Stanford — dẫn đầu bởi Yoonho Lee, cùng Chelsea Finn và Omar Khattab — xuất bản một paper định hình lại cách chúng ta nghĩ về tối ưu hệ thống AI.

Paper: Meta-Harness: End-to-End Optimization of Model Harnesses.

Ý tưởng cốt lõi giản dị đến bất ngờ: điều gì xảy ra nếu một coding agent có thể tự tối ưu harness của chính nó?

Thay vì một engineer thủ công inspect failures, điều chỉnh heuristics, và iterate qua vài thiết kế, Meta-Harness chạy một coding agent (Claude Code) trong search loop. Agent đọc source code, scores, và full execution traces của mọi harness trước đó thông qua filesystem. Rồi nó đề xuất harness mới. Vòng lặp tiếp tục.

Mỗi bước truy cập đến 10 triệu tokens diagnostic context. Không phải summary nén. Là code thô, thông báo lỗi, timeout logs, model outputs, tool calls — tất cả.

Tại sao cách tiếp cận filesystem lạ vậy

Đây là insight quan trọng nhất của paper, đáng để hiểu sâu.

Mọi phương pháp text optimization trước đó — Self-Refine, OPRO, TextGrad, GEPA, AlphaEvolve/OpenEvolve, Feedback Descent — đều nén feedback rất mạnh. Chúng dựa vào scalar scores, LLM-generated summaries, hoặc sliding window of recent candidates. Context khả dụng mỗi bước dao động từ 0.001 đến 0.026 triệu tokens.

Meta-Harness cấp cho proposer 10 triệu tokens mỗi bước. Gấp ba bậc độ lớn.

Phương Pháp              Context/Bước
─────────────────────────────────────
Self-Refine             0.001 Mtok
OPRO                    0.002 Mtok
TextGrad                0.015 Mtok
GEPA                    0.008 Mtok
AlphaEvolve             0.022 Mtok
TTT-Discover            0.026 Mtok
─────────────────────────────────────
Meta-Harness           10.000 Mtok    ← filesystem access

Tại sao con số này quan trọng? Vì harness failures rất khó chẩn đoán chỉ từ score và summary. Bạn cần nhìn thấy actual error message, truncated terminal output, chính xác tool call nào timed out. Compressed feedback loại bỏ thông tin cần thiết để trace một downstream failure ngược lại decision của harness trước đó.

Meta-Harness cho phép proposer chạy grep và cat trên filesystem, chỉ đọc cái cần thiết. Trong thực tế, agent đọc median 82 files mỗi iteration, tham chiếu hơn 20 prior candidates mỗi bước. Nó không ingest mọi thứ — nó query adaptively, như một developer giỏi đang debug production incident.

Ablation study chứng minh điều này: khi researchers xóa raw execution traces và chỉ cho proposer scores + LLM summaries, accuracy giảm từ 50% xuống 38.7% best-case. Summaries không khôi phục được tín hiệu bị mất. Thậm chí có thể làm tệ hơn.

Kết quả khiến mọi engineer phải ngồi thẳng lưng

Meta-Harness được đánh giá trên ba domain. Mỗi một kể một câu chuyện khác nhau về lý do harness engineering quan trọng.

Online text classification

Sử dụng GPT-OSS-120B, researchers search qua harnesses cho ba dataset — LawBench (215 classes), Symptom2Disease (22 classes), USPTO-50k (180 classes).

Harness                     Accuracy    Context Cost
────────────────────────────────────────────────────
Few-shot (tất cả)            40.8%      49.3K tokens
ACE (prior SOTA)             40.9%     203.0K tokens
Meta-Harness                 48.6%      45.5K tokens  ← +7.7pts, ít hơn 4x context

Harness được khám phá, đặt tên “Label-Primed Query,” đạt cao hơn 7.7 điểm so với harness thiết kế thủ công tốt nhất (ACE), trong khi dùng ít hơn 4x context tokens. Không harness nào được khám phá yêu cầu thêm LLM calls ngoài task-solving call chính.

Chỉ riêng LawBench — dataset khó nhất với 215 classes dễ nhầm lẫn — mức tăng là 16 điểm.

Và tốc độ: Meta-Harness khớp được accuracy cuối cùng của các text optimizer tốt nhất chỉ với 4 evaluations. OpenEvolve và TTT-Discover cần gấp 10 lần.

Math reasoning

Researchers search qua các retrieval programs cho các bài toán toán cấp IMO. Corpus hơn 500K bài toán từ 8 datasets. Harness có thể triển khai logic filtering, branching, và formatting tùy ý.

Phương Pháp          GPT-5.4n   GPT-5.4m   Gem-3F    GPT-20B    Trung Bình
──────────────────────────────────────────────────────────────────────────
Không Retriever       23.0%      28.8%      42.6%      47.6%     34.1%
BM25 Retrieval        30.2%      29.2%      46.6%      48.9%     37.5%
Meta-Harness          31.7%      30.4%      46.3%      50.6%     38.8%

Kết quả then chốt: một harness duy nhất cải thiện cả năm model held-out trung bình 4.7 điểm — bao gồm các model hoàn toàn chưa thấy trong search. Đây là genuine transfer, không phải overfitting.

Tại sao? Vì harness học được một retrieval strategy tổng quát — cách chọn và format examples — chứ không phải giải pháp cho bài toán cụ thể. Đó là sự khác biệt giữa ghi nhớ đáp án và học cách ôn thi.

Agentic coding (TerminalBench-2)

Đây là domain khó nhất. TerminalBench-2 đánh giá agents trên 89 task Dockerized — code translation, distributed ML setup, systems programming, bioinformatics, cryptanalysis. Đây là những task đòi hỏi long-horizon autonomous execution dưới complex dependencies.

Agent Claude Opus 4.6    Pass Rate
─────────────────────────────────
Claude Code               58.0%
Terminus 2                62.9%
Terminus-KIRA             74.7%
Capy                      75.3%
Meta-Harness              76.4%    ← #2 overall
ForgeCode                 81.8%    ← #1 (closed-source)

Agent Claude Haiku 4.5   Pass Rate
─────────────────────────────────
Claude Code               27.5%
Terminus-KIRA             33.7%
Goose                     35.5%
Meta-Harness              37.6%    ← #1 trong nhóm Haiku 4.5

Meta-Harness đạt top #2 trong tất cả Claude Opus 4.6 agents và top #1 trong tất cả Claude Haiku 4.5 agents. Một Haiku 4.5 agent — model rẻ, nhỏ — vượt qua các model lớn hơn, đắt hơn khi được trang bị harness tốt hơn.

Đó là luận điểm trong một con số: harness đôi khi quan trọng hơn model.

Thuật toán Meta-Harness — đơn giản hóa

Đây là core loop, stripped đến bản chất:

# Meta-Harness outer loop (đã đơn giản)

population = [harnesses_khởi_tạo]     # seed với baselines mạnh
filesystem = {}                        # lưu code, scores, traces

# Giai đoạn 1: Đánh giá candidates khởi tạo
for harness in population:
    result = evaluate(harness, model, tasks)
    filesystem[iteration] = {
        "code": harness.source_code,
        "score": result.metrics,
        "traces": result.execution_logs  # prompts, tool calls, errors
    }

# Giai đoạn 2: Agentic search
for iteration in range(N):
    # Proposer đọc filesystem adaptively qua grep/cat
    diagnosis = proposer.inspect(filesystem)
    new_harnesses = proposer.propose(diagnosis, count=k)
    
    for harness in new_harnesses:
        if validate_interface(harness):
            result = evaluate(harness, model, tasks)
            filesystem[iteration] = {
                "code": harness.source_code,
                "score": result.metrics,
                "traces": result.execution_logs
            }

# Giai đoạn 3: Trả về Pareto frontier (cân bằng accuracy/cost)
return pareto_frontier(filesystem.values())

Proposer là Claude Code với Opus-4.6, guided bởi một skill file tối thiểu mô tả cấu trúc thư mục và những gì nó có thể sửa. Mỗi harness là một file Python đơn. Một run điển hình đánh giá khoảng 60 harnesses qua 20 iterations.

Meta-Harness khác biệt ra sao

So sánh trực tiếp để thấy rõ:

Phương pháp dựa trên summary (GEPA, Feedback Descent) nén lịch sử thành textual summaries. Nhưng harness failures cần raw execution traces — không phải diễn giải của LLM về chuyện gì đã sai.

Phương pháp dựa trên score (OPRO, AlphaEvolve) vận hành trên scalar metrics. Score 35% cho biết đã fail, không cho biết tại sao hay component nào của harness gây ra.

Phương pháp last-candidate (Self-Refine, TextGrad) bắt đầu mỗi iteration từ đầu. Không có memory của prior candidates, không có comparative signal, không có khả năng phát hiện regression patterns.

Filesystem interface của Meta-Harness vượt qua cả ba hạn chế. Proposer có thể:

• Đọc full source code của bất kỳ prior candidate nào
• Trace một failure cụ thể qua nhiều candidates
• Phát hiện regression patterns bằng cách so sánh scores và traces song song
• Chuyển chiến lược sau nhiều lần fail cùng hướng

Hệ quả: điều này nghĩa gì cho bạn

Ba takeaways quan trọng cho cách bạn xây dựng AI systems.

Takeaway 1: đầu tư vào harness engineering skills, không phải prompt engineering

Meta-skill của 2026 không phải viết prompt hay hơn. Nó là thiết kế môi trường tốt hơn cho models vận hành. Nếu bạn là DevOps engineer xây CI runners, deployment pipelines, và infra automation — chúc mừng, bạn đã có 80% kỹ năng cần thiết. Harness chỉ là một discipline hạ tầng khác.

# Tư duy DevOps hiện tại của bạn chuyển đổi trực tiếp:
# CI linting  →  harness input validation
# Deployment gates  →  harness tool-call verification
# Monitoring + alerting  →  harness observability layer
# Rollback strategy  →  harness error recovery

Takeaway 2: model rẻ + harness tốt thắng model đắt + harness yếu

Kết quả TerminalBench-2 không thể chối cãi: một Haiku 4.5 agent với harness từ Meta-Harness (37.6%) vượt qua Claude Code (27.5%) và Terminus-KIRA (33.7%) — cả hai dùng cùng model Haiku 4.5. Chênh lệch giá giữa Haiku và Opus khoảng 50x. Chênh lệch hiệu năng? Chưa tới 2x.

Cost vs. Hiệu Năng (TerminalBench-2, Haiku 4.5):
─────────────────────────────────────────────────
Haiku + Meta-Harness:    37.6%  (~$0.10/1M tokens)
Claude Code + Opus 4.6:  58.0%  (~$5.00/1M tokens)

Harness thu hẹp phần lớn khoảng cách với 1/50 chi phí.

Takeaway 3: tối ưu harness tự động là biên giới tiếp theo

Meta-Harness chứng minh automated harness search hoạt động. Bước tiếp theo — mà authors đã nói rõ — là scaling nó tốt hơn. Better coding agents sẽ làm phương pháp này hiệu quả hơn tự động, không cần thay đổi outer loop. Proposer thông minh hơn khi coding assistants cải thiện, và harness cải thiện theo.

Đây là “đòn bẩy đắng” — bạn kéo một đòn bẩy (coding agent tốt hơn), và hai hệ thống cải thiện đồng thời (proposer và task solver). Đó là lợi thế compound.

Những hạn chế thành thật

Meta-Harness không phải viên đạn bạc, và quan trọng là phải rõ về giới hạn.

Chi phí tính toán. Một run điển hình đánh giá ~60 harnesses. Mỗi evaluation chạy full harness trên hàng trăm tasks. Với Claude Code Opus-4.6 làm proposer, điều này đắt đỏ. Không phải thứ bạn chạy trên mọi PR.

Đặc thù domain. Harnesses được khám phá là domain-specific. Harness text classification sẽ không giúp agentic coding workflow. Bạn vẫn cần chạy search per domain, per task distribution.

Filesystem vẫn còn non trẻ. Meta-Harness lưu mọi thứ dưới dạng files cho đơn giản. Sự tiến hóa tự nhiên là structured databases với query interfaces — nghĩ đến Postgres cho execution traces với full-text search. Nhưng đóng góp của paper là design choice (cấp cho proposer full history), không phải cơ chế storage.

Phán đoán con người vẫn thiết yếu. Pareto frontier cho bạn options. Con người vẫn chọn deployment cuối cùng — cân bằng accuracy, latency, context cost, và operational complexity.

Tóm lại

Paper Meta-Harness của Stanford đưa ra một tuyên bố mạnh mẽ, và bằng chứng ủng hộ: harness engineering không chỉ là craft — nó là một bài toán optimization formal mà agents có thể giải tốt hơn con người.

Khoảng chênh lệch hiệu năng lớn nhất trong hệ thống AI của bạn có lẽ không nằm ở model. Nó nằm ở code quyết định model thấy gì, được phép làm gì, và khi nào phải dừng.

Bạn có thể tiếp tục tweak prompts. Hoặc bắt đầu đối xử harness như một engineering discipline hạng nhất — thiết kế nó, đo lường nó, và có, tự động hóa việc cải thiện nó.

Câu chuyện ba kỹ sư codebase một triệu dòng không phải về model tốt hơn. Nó là về harness tốt hơn. Câu chuyện tương tự áp dụng cho hệ thống của bạn vào sáng mai lúc 9 giờ.

Xây harness trước. Model tự lo phần còn lại.

Tham khảo và đọc thêm:

• Lee et al. (2026) Meta-Harness: End-to-End Optimization of Model Harnesses
• OpenAI Harness Engineering
• Yoonho Lee Meta-Harness project page