เทียบชัด Agent Harness vs Framework vs MCP สถาปัตยกรรมไหนคุมอะไร

คำว่า Harness, Framework และ MCP มักถูกใช้แทนกันในการสนทนาเรื่องสถาปัตยกรรมของ Agent แต่ความจริงแล้วพวกมันอยู่ในเลเยอร์ที่ต่างกัน มีหน้าที่รับผิดชอบชัดเจน และเริ่มมีความคาบเกี่ยวกันมากขึ้นในปัจจุบัน

บทความนี้จะแยกแยะทั้ง 3 ส่วนผ่านมุมมองเชิงปฏิบัติการว่า เลเยอร์ไหนเป็นเจ้าของ execution loop, state, tool transport, permissions และ recovery เพื่อให้ผู้พัฒนาเลือกใช้เครื่องมือได้อย่างถูกต้อง

3 หมวดหมู่หลัก

Agent harness: คือระบบประมวลผล (execution system) ที่ห่อหุ้มโมเดลและเปลี่ยนให้เป็น Agent ที่ทำงานได้จริง ทำหน้าที่จัดการ conversation state, สตรีมการประมวลผล, บังคับใช้ sandbox และนโยบายการอนุมัติ ตัวอย่างเช่น Codex as a platform ของ OpenAI และ Claude Agent SDK ของ Anthropic
Agent framework: คือไลบรารีของพื้นฐาน (primitives) สำหรับประกอบ Agent ครอบคลุมถึง model clients, tool abstractions, orchestration และ memory interfaces เช่น LangGraph, OpenAI Agents SDK และ Microsoft Agent Framework
MCP: Model Context Protocol คือโปรโตคอลการสื่อสาร (wire protocol) ที่สร้างมาตรฐานให้แอปพลิเคชัน LLM ค้นหาและเรียกใช้ความสามารถจากเซิร์ฟเวอร์ได้ ไม่ได้เป็นเจ้าของ loop หรือ state แต่เป็นข้อตกลง (contract) ในการสื่อสารข้อมูล

ตารางสรุปความเป็นเจ้าของ (Ownership matrix)

ตารางนี้จับคู่ความรับผิดชอบแต่ละอย่างกับเลเยอร์ที่เป็นเจ้าของโดยค่าเริ่มต้น คำว่า "เป็นเจ้าของ (Owns)" หมายถึงเลเยอร์นั้นเป็นผู้กำหนดและบังคับใช้พฤติกรรม ส่วน "เปิดเผย (Exposes)" หมายถึงการจัดเตรียมช่องทางให้เข้าถึงได้แต่ไม่ได้ตัดสินใจเรื่องนโยบาย

ความรับผิดชอบ	Agent harness	Agent framework	MCP
Execution loop	เป็นเจ้าของ: Loop แบบคงที่ระดับโปรดักชัน	เป็นเจ้าของโครงสร้าง: คุณกำหนดค่าและนโยบายเอง	ไม่มี: เป็นแบบ Request/response เท่านั้น
Agent state และ memory	เป็นเจ้าของ: Sessions, การทำงานต่อ และ Checkpoint	เปิดเผย: Checkpointers, session stores	ไม่มีในระดับโปรโตคอล
Tool transport	เรียกใช้: เครื่องมือในตัวบวกกับ MCP client	เรียกใช้: Function tools บวกกับ MCP client	เป็นเจ้าของ: JSON-RPC ผ่าน stdio หรือ HTTP
Permissions และการอนุมัติ	เป็นเจ้าของ: โหมด Permission และ sandbox	เปิดเผย: Guardrails และ middleware	ส่งต่อให้ host: ไม่สามารถบังคับใช้เองได้
Recovery	เป็นเจ้าของ: การกลับมาทำงานต่อ และการย้อนคืน	เปิดเผย: Durable execution และการเล่นซ้ำ	บางส่วน: ส่วนขยาย Tasks สำหรับงานที่ยาวนาน
การแยกส่วนและ Sandboxing	เป็นเจ้าของ: OS sandbox, containers	ทางเลือก: Hosted sandboxes หรือ micro-VMs	ไม่มี
Multi-agent orchestration	เป็นเจ้าของรูปแบบ: Subagents, dynamic workflows	เป็นเจ้าของ primitives: Graphs, handoffs	ไม่มี: A2A ครอบคลุมเรื่อง agent-to-agent

ใครเป็นเจ้าของ execution loop

Agent ทุกตัวทำงานเป็น loop คือส่ง context ไปยังโมเดล, อ่านคำตอบ, ประมวลผลเครื่องมือ และส่งผลลัพธ์กลับไปทำซ้ำ ทั้ง harness และ framework ต่างก็ใช้ loop นี้แต่มีระดับการควบคุมต่างกัน

Harness loop มักจะเป็นแบบสำเร็จรูป เช่น Claude Agent SDK ที่ระบุขั้นตอน loop ไว้ 5 ขั้นตอนตายตัว แม้จะมี hooks ให้ดักจับข้อมูลได้แต่ตัว loop เองไม่ใช่สิ่งที่คุณจะเขียนขึ้นใหม่ได้ทั้งหมด ขณะที่ Framework loop จะเปิดกว้างกว่า เช่น OpenAI Agents SDK ที่จะหยุดเมื่อได้ผลลัพธ์สุดท้ายหรือเกิดข้อผิดพลาดตามเงื่อนไขที่คุณตั้งไว้

สำหรับ MCP นั้นไม่มี loop ในตัวตั้งแต่ข้อกำหนดรุ่นปี 2026 มันเป็นเพียงตัวกำหนดว่าการเรียกใช้งานเครื่องมือควรมีหน้าตาเป็นอย่างไรบนสายส่งข้อมูล โดยให้ loop ของฝั่ง host เป็นคนตัดสินใจเองว่าจะเรียกใช้งานเมื่อใด

ใครเป็นเจ้าของ state

ในเลเยอร์ Harness ข้อมูลสถานะ (State) จะคงอยู่ข้าม session เช่น Claude Agent SDK ที่รองรับการแยกสาขา (fork) และการทำไฟล์ checkpoint เพื่อคืนค่าสถานะเดิมได้ทันที รวมถึงมีการจัดการหน่วยความจำและบีบอัด context อัตโนมัติ

ทางด้าน Framework จะเปิดสถานะผ่าน primitives เช่น durable execution ของ LangGraph ที่ให้ผู้พัฒนาเลือกโหมดความทนทานของข้อมูลเอง หากเลือกไม่เหมาะสมและระบบล่ม ข้อมูลสถานะอาจสูญหายได้

ส่วน MCP ในรุ่นปัจจุบันได้ปรับให้เป็นแบบไร้สถานะ (stateless) โดยสิ้นเชิง คำแนะนำคือหากเซิร์ฟเวอร์ต้องการเก็บสถานะข้ามการเรียกใช้งาน ให้สร้าง handle ขึ้นมาผ่านเครื่องมือแล้วให้โมเดลส่งกลับมาเป็น argument แทน

ใครเป็นเจ้าของ tool transport

นี่คือส่วนที่ MCP เป็นเจ้าของโดยสมบูรณ์ โดยทำหน้าที่กำหนด primitives ฝั่งเซิร์ฟเวอร์ทั้ง tools, resources และ prompts ผ่าน JSON-RPC 2.0 ซึ่งมียอดดาวน์โหลด SDK รวมกันเกิน 1 พันล้านครั้งแล้ว สะท้อนถึงการเป็นมาตรฐานกลางของอุตสาหกรรม

Harnesses และ frameworks ต่างก็อยู่บนยอดของ MCP ในฐานะ client โดยทั้ง Claude Code และ Microsoft Agent Framework 1.0 ต่างรองรับ MCP เพื่อเชื่อมต่อกับบริการภายนอกอย่าง GitHub หรือ Supabase ได้อย่างราบรื่น

ใครเป็นเจ้าของ permissions

ข้อกำหนดของ MCP ระบุชัดเจนว่าสิทธิการใช้งานต้องขึ้นอยู่กับการยินยอมของผู้ใช้ผ่าน Host เท่านั้น ดังนั้น Harness จึงเป็นผู้รับหน้าที่เป็นเจ้าของโมเดล permission ตั้งแต่ต้นจนจบ เช่น Claude Code ที่มีโหมดให้เลือกตั้งแต่ default ไปจนถึง bypassPermissions

ในขณะที่ Framework จะให้เพียงแค่ hook สำหรับตรวจสอบ เช่น OpenAI Agents SDK ที่มีระบบ guardrails และ tripwire เพื่อหยุดการทำงานทันทีเมื่อพบเงื่อนไขที่อันตราย แต่ผู้พัฒนาต้องเป็นคนเขียนตรรกะการอนุมัติและ UI เองทั้งหมด

ใครเป็นเจ้าของ recovery

Harness แสดงประสิทธิภาพสูงสุดในการกู้คืนระบบ โดยสามารถกลับมาทำงานต่อจากที่ค้างไว้ได้แม้ terminal จะถูกปิด การออกแบบ harness ที่ดีช่วยเพิ่มคะแนน benchmark ของโมเดลเดิมได้มหาศาล เช่นการทดสอบ ARC-AGI-3 ที่คะแนนพุ่งจาก 13.3% เป็น 38.3% เพียงแค่เปลี่ยน harness

ฝั่ง Framework การกู้คืนขึ้นอยู่กับความเป็น determinism ของผู้พัฒนาที่ต้องห่อหุ้มผลข้างเคียงไว้ใน tasks เพื่อให้การเล่นซ้ำ (replay) ปลอดภัย ส่วน MCP มีส่วนขยาย io.modelcontextprotocol/tasks มาช่วยรองรับงานที่รันยาวนานในระดับการเรียก tool ครั้งเดียว

การเปรียบเทียบสถาปัตยกรรม

                   +------------------------------------------+
  Application       |  Product ของคุณ: UI, records, กฎธุรกิจ    |
                    |  ผังการให้ความยินยอม                     |
                    +------------------------------------------+
                          |                     |
                          v                     v
  Runtime layer     +----------------+   +-----------------------+
  (เลือกอย่างหนึ่ง    |  AGENT HARNESS |   |  AGENT FRAMEWORK      |
   หรือรวมกัน)       |  loop แบบคงที่  |   |  loop ที่ประกอบได้      |
                    |  sessions      |   |  checkpointers        |
                    |  permissions   |   |  guardrails/interrupt |
                    |  sandbox       |   |  graphs, handoffs     |
                    |  การบีบอัด      |   |  middleware, tracing  |
                    +----------------+   +-----------------------+
                          |                     |
                          +----------+----------+
                                     v
  Transport layer   +------------------------------------------+
                    |  MCP (JSON-RPC 2.0, stdio / Streamable   |
                    |  HTTP): tools, resources, prompts,       |
                    |  elicitation, Tasks extension            |
                    +------------------------------------------+
                                     |
                                     v
  Capability layer  +------------------------------------------+
                    |  MCP servers: GitHub, Figma, Supabase,   |
                    |  Sentry, Linear, internal APIs           |
                    +------------------------------------------+

จุดที่แต่ละหมวดหมู่คาบเกี่ยวกัน

ปัจจุบันขอบเขตเริ่มจางลงใน 3 ทิศทางหลัก: Frameworks เริ่มดูดกลืน Harnesses โดยเพิ่มเลเยอร์สำเร็จรูปเข้ามา, Harnesses เริ่มกลายเป็นแพลตฟอร์มด้วยการปล่อย SDK ให้ฝังลงในผลิตภัณฑ์อื่นได้ และ MCP เริ่มเพิ่มฟีเจอร์การโต้ตอบที่คล้ายกับความสามารถของ Agent

อย่างไรก็ตาม มีคำหนึ่งที่ไม่คาบเกี่ยวคือ A2A (Agent-to-Agent) ซึ่งเป็นโปรโตคอลแยกต่างหากสำหรับการสื่อสารระหว่าง Agent ด้วยกัน โดย MCP จะทำหน้าที่เชื่อม Agent เข้ากับเครื่องมือ ส่วน A2A จะเชื่อม Agent เข้ากับ Agent ตัวอื่น

วิธีการประกอบ Stack

หากต้องการคุม Flow เอง: เริ่มต้นด้วย Framework เพื่อกำหนดรูปทรงของ loop และ graph ที่ต้องการทดสอบทีละส่วนได้
หากต้องการความรวดเร็วและเสถียร: เลือก Harness ที่มีระบบ permission และ recovery ในตัว เหมาะสำหรับงานด้านโค้ดหรืองานวิจัย
การเชื่อมต่อเครื่องมือ: ใช้ MCP เสมอไม่ว่าจะใช้เลเยอร์ด้านบนเป็นอะไร เพื่อให้สร้างหน้าอินเทอร์เฟซเครื่องมือเพียงครั้งเดียวและใช้ซ้ำได้ทุกที่

รูปแบบการใช้งานจริงในปี 2026 มักจะเป็นแบบลูกผสม (hybrid) โดยใช้ framework จัดการโครงสร้างภายนอก และใช้ harness รันขั้นตอนที่หนักหน่วงภายใน sandbox ซึ่งทั้งสามส่วนนี้เสริมพลังกันมากกว่าจะเป็นคู่แข่งกัน

แหล่งอ้างอิง

Model Context Protocol, Specification 2026-07-28
MCP Blog, The 2026-07-28 Specification
Linux Foundation, Formation of the Agentic AI Foundation
OpenAI, Harness engineering: leveraging Codex in an agent-first world
Anthropic, Claude Agent SDK overview
Microsoft, Microsoft Agent Framework Version 1.0
LangChain, LangGraph durable execution
DeepSeek, DeepSeek Harness