Harness Engineering: Pagbuo ng mga System sa Paligid ng AI Agents (2026)

TL;DR

Ano Is Harness Engineering?

Ang harness engineering ay ang disiplina ng pagbuo ng mga system, tool, constraint, at feedback loop sa paligid ng AI coding agents upang gawin itong reliable at produktibo.

Ang termino ay binuo ni Mitchell Hashimoto (co-founder ng HashiCorp) at nakuha ang atensyon ng nakararami nang inilathala ng OpenAI ang kanilang Codex article tungkol sa paksa noong unang bahagi ng 2026.

Ang pangunahing ideya ay simple:

Agent = Model + Harness

Ang model ang nagbibigay ng talino (intelligence). Ang harness ang gumagawa sa talinong iyon na maging kapaki-pakinabang. Ang mas mahusay na harness ay madalas na mas mahalaga kaysa sa mas mahusay na model.

Bakit Ito Mahalaga Ngayon

Noong 2025, lahat ng team ay nag-adopt ng AI coding agents. Ngayong 2026, ang mga nanalong team ay ang mga nag-engineer ng kanilang agent environments — hindi lang basta pumili ng pinakamahusay na model.

Ang gabay na prinsipyo ni Mitchell Hashimoto:

"Anumang oras na makakita ka ng pagkakamali ng isang agent, maglaan ng oras upang mag-engineer ng solusyon upang hindi na kailanman muling magawa ng agent ang pagkakamaling iyon."

Hindi ito prompt engineering. Ito ay systems engineering para sa AI.

Ang Katibayan: Harness > Model

Nagpatakbo ang LangChain ng isang controlled experiment sa Terminal Bench 2.0. Nang hindi binabago ang pinagbabatayang model, pinahusay nila ang accuracy ng kanilang coding agent mula 52.8% hanggang 66.5% — isang 26% na pagpapabuti — sa pamamagitan lamang ng pagpapahusay sa harness.

Kasama sa mga pagbabago ang:

• Mas mahusay na mga context file (AGENTS.md)


• Structured output constraints


• Self-verification loops


• Tool optimization

Ang 7 Component ng isang Harness

1. Context Engineering

Ang context engineering ang pundasyon. Dito mo binibigyan ang agent ng mapa ng iyong codebase, ang iyong mga convention, at ang iyong mga constraint.

• CLAUDE.md / AGENTS.md na mga file sa root ng iyong repo
• Mga directory map at architecture overview
• Mga coding style rule at naming convention

# CLAUDE.md example
## Architecture
- src/app/ — Next.js app router pages
- src/lib/ — shared utilities and API clients
- src/components/ — React components (co-located styles)

## Rules
- Use server components by default
- Never import from node_modules directly in components
- All API calls go through src/lib/api.ts

2. Architectural Constraints

Sa halip na umasang pipiliin ng agent ang tamang architecture, ipatupad ito.

• Mahigpit na layered architectures na naba-validate ng mga linter
• Structural tests na nagfe-fail kung ang mga pattern ay nalabag
• Mga import restriction sa pamamagitan ng ESLint rules o custom scripts

3. Tools & MCP Servers

Kailangan ng mga agent ng mga tool para maging epektibo. Inilalantad ng pinakamahusay na mga harness ang internal tooling sa pamamagitan ng:

• CLI wrappers — mas piliin ang mga kilalang CLI (git, docker, npm) kaysa sa custom tooling
• MCP (Model Context Protocol) servers — hayaan ang mga agent na tumawag sa iyong internal APIs, databases, at services
• File system access — naka-scope sa mga partikular na directory upang maiwasan ang accidental damage

4. Sub-Agents & Context Firewalls

Ang mga long-running agent sessions ay nag-iipon ng context na sa huli ay nagpapababa ng performance — tinatawag itong context rot.

Ang solusyon: mga sub-agent na may mga context firewall.

• Hatiin ang mga kumplikadong task sa mga discrete na sub-task
• Ang bawat sub-task ay tumatakbo sa sarili nitong session na may fresh context
• Ipasa lamang ang mga structured result sa pagitan ng mga agent, hindi ang raw conversation

1. Initializer Agent — nagpaplano ng trabaho, gumagawa ng feature list
2. Coding Agent — isinasagawa ang bawat feature nang hiwalay

5. Hooks & Back-Pressure

Mga automated feedback loop na nakakahuli ng mga pagkakamali bago pa ito lumala:

• Pre-commit hooks — type-checking, linting, formatting
• Test runners — dapat magpatakbo ng tests ang mga agent pagkatapos ng bawat pagbabago
• Build verification — mag-fail agad sa mga broken build

6. Self-Verification Loops

Pilitin ang mga agent na i-verify ang sarili nilang gawa bago markahan ang mga task bilang tapos na:

• Patakbuhin ang test suite pagkatapos ng mga pagbabago
• I-check kung pumasa ang build
• I-verify kung ang output ay tumutugma sa specification
• Kumuha ng screenshot at ikumpara (para sa UI work)

7. Progress Documentation

Para sa mga gawaing matagal matapos (30+ minuto):

• Magpanatili ng progress file na nagta-track ng mga nakumpletong hakbang
• Mag-commit ng trabaho nang madalas upang ang mga susunod na session ay makapagpatuloy
• Gumamit ng mga structured task list, hindi freeform notes

Mga Real-World na Resulta

OpenAI Codex Team

3 engineer ang nakagawa ng million-line codebase nang walang manually-written code sa loob ng 5 buwan. Nag-average sila ng 3.5 merged PRs bawat engineer kada araw — isang throughput na imposible kung walang mature na harness.

Kasama sa kanilang harness ang: strict commit conventions, automated testing sa bawat PR, at agent-aware CI/CD pipelines.

Stripe's "Minions"

Ang internal system ng Stripe ay nakakagawa ng 1,000+ merged PRs kada linggo gamit ang AI agents. Kasama sa kanilang harness ang:

• Tightly scoped task definitions
• Mandatory code review ng mga tao
• Automated regression testing
• Rollback automation

Anthropic's Two-Agent Architecture

Inilathala ng Anthropic ang kanilang diskarte sa mga epektibong harness para sa long-running agents:

• Structured feature lists bilang handoff format sa pagitan ng mga agent
• Git-based progress tracking upang ang mga agent ay makapag-resume pagkatapos ng interruption
• Explicit exit criteria upang malaman ng mga agent kung kailan hihinto

Paano Simulan ang Pagbuo ng Iyong Harness

Hakbang 1: Gumawa ng Iyong Context File

Magdagdag ng CLAUDE.md (o AGENTS.md) sa iyong project root:

# Project: [Iyong Project]

## Stack
[Framework, language, database, hosting]

## Architecture
[Directory structure na may one-line descriptions]

## Rules
[5-10 mahigpit na panuntunan na dapat sundin ng agent]

## Common Tasks
[Paano magpatakbo ng tests, build, deploy]

Hakbang 2: Magdagdag ng Structural Constraints

# Halimbawa: ESLint rule na nagbabawal ng direktang DB imports sa components
# .eslintrc — no-restricted-imports rule

Mag-set up ng pre-commit hooks na awtomatikong nagpapatupad ng iyong mga panuntunan.

Hakbang 3: Bumuo ng Verification Loops

Siguraduhin na ang iyong agent ay kaya nang:

1. Magpatakbo ng tests (npm test, pytest, atbp.)


2. Mag-check ng types (tsc --noEmit, mypy)


3. Mag-lint (eslint ., ruff check)

Hakbang 4: I-scope ang Agent Sessions

Huwag ibigay sa agent ang iyong buong backlog. Sa halip:

• Isang feature bawat session
• Isang bug fix bawat session
• Malinaw na acceptance criteria para sa bawat task

Hakbang 5: I-iterate ang Harness

Sa bawat pagkakataon na magkamali ang agent:

1. Alamin ang root cause
2. Magdagdag ng rule, constraint, o hook na pipigil dito
3. I-test ang fix

Harness Engineering vs. Prompt Engineering

Ang prompt engineering ay kapaki-pakinabang pa rin, ngunit ito ay maliit na bahagi lamang ng kabuuan. Ang harness engineering ang multiplier.

Ang Umuusbong na Papel: Ang Harness Engineer

Ang engineering ay nahahati sa dalawang bahagi:

1. Environment Building — paglikha ng structure, tools, constraints, at feedback loops
2. Work Management — pagpaplano, pagre-review, at pag-orchestrate ng parallel agent sessions

Hindi Dapat Ipagkamali Sa: Harness.io

Kung hinanap mo ang "Harness Engineering" habang naghahanap ng DevOps platform — ang Harness.io ay isang ganap na hiwalay na bagay. Ito ay isang AI-powered CI/CD platform na may halagang $5.5B (noong Disyembre 2025) na nag-aalok ng continuous integration, delivery, feature flags, cloud cost management, at security testing.

Bagama't pareho ang pangalan ng Harness.io at harness engineering, magkaibang problema ang nilulutas ng mga ito. Gayunpaman, mayroong kawili-wiling overlap: ang AI-powered DevOps ng Harness.io ay masasabing isang application ng harness engineering principles sa deployment pipeline.

Bottom Line

Ang model ang makina. Ang harness ang kotse. Walang nananalo sa karera gamit lang ang makina.

Kung gumagamit ka ng AI coding agents sa 2026 at hindi nag-i-invest sa iyong harness, sinasayang mo ang karamihan ng halaga nito. Magsimula sa isang context file, magdagdag ng constraints, bumuo ng verification loops, at mag-iterate sa tuwing may nasisira.

Ang mga team na pinakamabilis mag-ship ay hindi gumagamit ng mas mahusay na models. Gumagamit sila ng mas mahusay na harnesses.