เจาะลึกสถาปัตยกรรมเอเจนต์: Agent Harness vs Framework vs MCP ต่างกันอย่างไร?

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

บทความนี้จะพาไปแยกส่วนประกอบทั้ง 3 ผ่านคำถามสำคัญ: เลเยอร์ไหนเป็นเจ้าของ execution loop, state, การรับส่งเครื่องมือ (tool transport), การอนุญาต (permissions) และการกู้คืนระบบ (recovery)?

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

Agent harness: คือระบบประมวลผล (execution system) ที่ห่อหุ้มโมเดลและเปลี่ยนให้เป็นเอเจนต์ที่ทำงานได้จริง โดย OpenAI นิยามในโพสต์ Codex as a platform ว่า harness ทำหน้าที่จัดการสถานะการสนทนา, ลำดับการประมวลผล และการใช้เครื่องมือ รวมถึงบังคับใช้ sandbox และนโยบายการอนุมัติ เช่นเดียวกับ Claude Agent SDK ของ Anthropic ที่ใช้ระบบ loop และการจัดการ context ชุดเดียวกับ Claude Code
Agent framework: คือไลบรารีชุดเครื่องมือสำหรับสร้างเอเจนต์ ประกอบด้วย model clients, การจัดการลำดับงานแบบ graph, และหน่วยความจำ ตัวอย่างที่ชัดเจนคือ LangGraph, OpenAI Agents SDK และ Microsoft Agent Framework ซึ่ง framework จะให้โครงร่างมา แต่ผู้พัฒนาต้องเป็นคนกำหนดนโยบายเอง
MCP: Model Context Protocol เป็นโปรโตคอลการสื่อสาร (wire protocol) ไม่ใช่ runtime มีหน้าที่สร้างมาตรฐานให้แอปพลิเคชัน LLM ค้นหาและเรียกใช้เครื่องมือผ่าน JSON-RPC 2.0 ปัจจุบันอยู่ภายใต้การดูแลของ Agentic AI Foundation โดย MCP ไม่ได้เป็นเจ้าของ loop แต่เป็นเจ้าของ "ข้อตกลง" ระหว่างเอเจนต์และเครื่องมือ

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

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

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

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

เอเจนต์ทุกตัวทำงานบน loop เริ่มตั้งแต่ส่ง context ให้โมเดล ไปจนถึงการประมวลผลเครื่องมือ ทั้ง harness และ framework ต่างใช้งานส่วนนี้แต่มีระดับการควบคุมที่ต่างกัน

ในระบบ Harness loop อย่าง Claude Agent SDK จะมีขั้นตอนที่ตายตัว 5 ขั้นตอนเพื่อรันจนกว่าจะได้คำตอบที่ ไม่มีการเรียกเครื่องมือ แม้จะมี hook ให้ดักจับข้อมูล แต่ตัว loop หลักไม่สามารถเขียนใหม่ได้ ต่างจาก Framework loop เช่นใน OpenAI Agents SDK ที่ให้ความยืดหยุ่นสูงกว่า หากรันเกินเพดานที่กำหนดจะเกิด error อย่าง MaxTurnsExceeded ให้ผู้พัฒนาจัดการต่อเอง

ขณะที่ MCP ไม่มีระบบ loop ในตัวตาม ข้อกำหนดวันที่ 2026-07-28 ทุกการร้องขอเป็นอิสระต่อกัน (stateless) โดย host จะเป็นผู้ตัดสินใจเองว่าจะเรียกเครื่องมือเมื่อใด

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

สำหรับ Harness สถานะข้อมูลจะคงอยู่ข้ามเซสชัน ตัวอย่างเช่น Claude Agent SDK ที่รองรับ sessions ซึ่งสามารถกลับมาทำงานต่อหรือแยกสาขา (fork) ได้ รวมถึงมีระบบ File checkpointing เพื่อกู้คืนไฟล์กลับสู่สถานะก่อนหน้า

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

ส่วน MCP นั้นชัดเจนว่าเป็นแบบ stateless หากเซิร์ฟเวอร์ต้องการเก็บสถานะ ต้องใช้วิธีสร้าง handle จากเครื่องมือแล้วให้ โมเดลส่งกลับมาเป็นพารามิเตอร์ ในภายหลัง

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

นี่คือพื้นที่เดียวที่ MCP เป็นเจ้าของโดยสมบูรณ์ โดยกำหนดมาตรฐานการสื่อสารผ่าน JSON-RPC 2.0 ซึ่งได้รับความนิยมอย่างสูงจนมียอดดาวน์โหลด SDK รวมเกิน 1 พันล้านครั้ง ทั้งใน Python และ TypeScript

ในปัจจุบันทั้ง harnesses และ frameworks ต่างทำงานอยู่บน MCP ในฐานะ client เช่น Codex ที่เชื่อมต่อกับ MCP servers และ Microsoft Agent Framework 1.0 ที่รองรับทั้ง MCP และ A2A ทำให้โปรโตคอลนี้กลายเป็นรากฐานสำคัญที่ทุกระบบใช้ร่วมกัน

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

ข้อกำหนด MCP ระบุว่าการอนุญาตเป็นหน้าที่ของ Host และ ตัวโปรโตคอลเองไม่สามารถบังคับใช้ความปลอดภัยได้

Harness อย่าง Claude Code จะมี โหมดการอนุญาต ถึง 6 ระดับ ตั้งแต่โหมด default ไปจนถึง bypassPermissions ส่วน Framework จะให้เพียงจุดเชื่อมต่ออย่าง guardrails หรือคำสั่ง interrupt() ใน LangGraph เพื่อให้ผู้พัฒนาไปเขียนตรรกะการอนุมัติและ UI ต่อเอาเอง

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

การกู้คืนเป็นจุดที่ Harness แสดงประสิทธิภาพสูงสุด OpenAI รายงานว่าการใช้ Codex harness ช่วยเพิ่มคะแนน benchmark GPT-5.6 Sol จาก 13.3% เป็น 38.3% โดยใช้โมเดลเดิมแต่ปรับปรุงระบบการกู้คืนและการย่อ context

สำหรับ Framework การกู้คืนขึ้นอยู่กับการออกแบบของผู้พัฒนา เช่น การทำให้ nodes เป็น idempotent เพื่อให้ การรันกลับมาทำงานต่อได้ ส่วน MCP รองรับเพียงส่วนขยาย io.modelcontextprotocol/tasks สำหรับติดตามงานที่รันนานๆ เท่านั้น

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

                   +------------------------------------------+
  Application       |  ผลิตภัณฑ์ของคุณ: UI, บันทึกข้อมูล, กฎธุรกิจ    |
                    |  ขั้นตอนการให้ความยินยอม                    |
                    +------------------------------------------+
                          |                     |
                          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 / HTTP):       |
                    |  เครื่องมือ, ทรัพยากร, พรอมต์,              |
                    |  elicitation, ส่วนขยาย Tasks             |
                    +------------------------------------------+
                                     |
                                     v
  Capability layer  +------------------------------------------+
                    |  MCP servers: GitHub, Figma, Supabase,   |
                    |  Sentry, Linear, API ภายใน               |
                    +------------------------------------------+

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

ปัจจุบันขอบเขตเริ่มเลือนลางลง Frameworks เริ่มผนวกรวมเลเยอร์ Harness เข้ามาในตัว เช่น Microsoft Agent Framework ที่เพิ่มฟีเจอร์ย่อ context และ sandbox เข้ามา ขณะที่ Harnesses เองก็เริ่มเปิด SDK ให้ใช้งานในรูปแบบแพลตฟอร์มมากขึ้น เช่น DeepSeek Harness v0.1

ส่วน MCP แม้จะเพิ่มฟีเจอร์อย่าง Tasks หรือ Elicitation แต่ผู้ดูแลยังคงยืนยันที่จะรักษาแกนหลักให้เป็นมาตรฐานอินเทอร์เฟซ มากกว่าที่จะข้ามเส้นไปเป็นตัวเอเจนต์เอง

วิธีเลือกใช้งานให้เหมาะสม

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

ในอนาคตอันใกล้ รูปแบบที่นิยมที่สุดจะเป็นแบบไฮบริด โดยใช้ Framework คุมโครงสร้างชั้นนอก ใช้ Harness รันงานหนักใน sandbox และใช้ MCP ในการสื่อสารกับเครื่องมือทั้งหมด