อย่าเป็นแค่ 'loop engineer' — วงจร agent เป็นเพียงชิ้นเดียวของ harness

ปีนี้มีคำใหม่ที่คนสาย AI agent พูดถึงกันหนักมากคือ "loop engineering" (ทั้งวงการเรียก 2026 ว่า "ปีของ harness") — แนวคิดที่ว่าแทนที่คุณจะนั่งพิมพ์สั่ง agent ทีละคำสั่ง คุณ "ออกแบบวงจร (loop)" ที่มันวิ่งเอง ค้นงานเอง เรียกเครื่องมือเอง ตรวจงานเอง จนกว่าจะถึงเป้า ฟังดูเท่และมันก็เป็นทักษะจริง แต่ผมในฐานะคนทำ model risk อยากเตือนอะไรหนึ่งอย่างตั้งแต่บรรทัดแรก — loop มันก็แค่ชิ้นเดียวของ harness ทั้งก้อน และถ้าคุณโฟกัสแค่ loop คุณจะได้ agent ที่ "วิ่งเองได้" แต่ "วิ่งเข้ากำแพงเองก็ได้เหมือนกัน"

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

ทวนก่อน: harness คืออะไร แล้ว loop อยู่ตรงไหน

ผมเคยแยก harness ออกเป็น 5 ชิ้นไว้ใน Harness คืออะไร — ทำไมความเก่งของ AI agent ส่วนใหญ่อยู่นอกตัวโมเดล คือ เครื่องมือ (tools) · การจัดบริบท (context) · สิทธิ์และการอนุมัติ (permission) · hook/middleware · และวงจรการทำงาน (the loop) ถ้าให้เปรียบง่าย ๆ โมเดลคือสมอง harness คือร่างกายกับกฎที่ทำให้สมองลงมือทำงานจริงได้

สังเกตว่า "the loop" เป็น 1 ใน 5 ชิ้น เท่านั้น มันคือหัวใจที่ทำให้สิ่งนี้เป็น "agent" ไม่ใช่แค่แชท — คือส่วนที่วน คิด → เรียกเครื่องมือ → เห็นผล → คิดต่อ จนงานเสร็จ "loop engineering" คือการทำชิ้นนี้ให้ดี ซึ่งสำคัญจริง แต่มันไม่ใช่ทั้ง harness และไม่ใช่ชิ้นที่ยากที่สุดด้วยซ้ำ

ทำไมมันสำคัญกับเรา: เวลาเห็นศัพท์ใหม่มาแรง ให้ถามก่อนว่ามันคือ "ทั้งเรื่อง" หรือ "ชิ้นหนึ่งของเรื่อง" loop engineering คืออย่างหลัง — ถ้าเข้าใจผิดว่าทำ loop เสร็จ = ทำ agent เสร็จ คุณจะข้ามชิ้นที่คุมความเสี่ยงไปทั้งหมด

พิสูจน์ด้วยโค้ด: ตัว loop จริง ๆ สั้นแค่นี้

หลายคนคิดว่า "วงจรของ agent" ต้องเป็นของซับซ้อน ความจริงมันคือ while ลูปอันเดียว นี่คือ agent ที่ทำงานได้จริง — รับโจทย์ อ่านไฟล์เอง แล้วสรุป — เขียนด้วย Claude API ทั้งหมดประมาณ 30 บรรทัด (ตัว loop จริง ๆ คือบล็อก while ~12 บรรทัด):

import anthropic

client = anthropic.Anthropic()

# เครื่องมือเดียว: อ่านไฟล์แล้วคืนเนื้อหา
def read_file(path):
    with open(path) as f:
        return f.read()

tools = [{
    "name": "read_file",
    "description": "อ่านไฟล์ข้อความจาก path ที่ระบุ แล้วคืนเนื้อหาทั้งหมด",
    "input_schema": {
        "type": "object",
        "properties": {"path": {"type": "string"}},
        "required": ["path"],
    },
}]

messages = [{"role": "user", "content": "อ่านไฟล์ report.txt แล้วสรุปให้หน่อย"}]

# ── นี่คือ 'the loop' ทั้งหมด: วนจนกว่าโมเดลจะเลิกเรียกเครื่องมือ ──
while True:
    resp = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=4096,
        tools=tools,
        messages=messages,
    )
    if resp.stop_reason != "tool_use":      # โมเดลตอบเสร็จแล้ว
        break
    messages.append({"role": "assistant", "content": resp.content})
    results = []
    for block in resp.content:
        if block.type == "tool_use":
            out = read_file(**block.input)  # <-- harness ลงมือทำจริงตรงนี้
            results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": out,
            })
    messages.append({"role": "user", "content": results})

print(next(b.text for b in resp.content if b.type == "text"))

ก่อนรันติดตั้ง pip install anthropic และตั้งค่า ANTHROPIC_API_KEY แล้วทำ report.txt ไฟล์เดียวไว้ในโฟลเดอร์ โค้ดนี้จะ: ส่งโจทย์ให้โมเดล → โมเดลขอเรียก read_file → โค้ดของเรา ไปอ่านไฟล์จริง → ส่งเนื้อหากลับเข้าโมเดล → วนจนโมเดลตอบสรุปออกมา นี่แหละ "agentic loop" ครบวงจร ไม่มีเวทมนตร์อะไรเลย

ทำไมมันสำคัญกับเรา: จุดที่คนมองข้ามคือบรรทัด out = read_file(**block.input) — โมเดลแค่ "ตัดสินใจ" ว่าจะเรียกเครื่องมือ แต่ harness (โค้ดของเรา) เป็นคน "ลงมือ" โมเดลไม่ได้แตะไฟล์เอง เราต่างหากที่แตะ ตรงนี้แหละที่อำนาจและความเสี่ยงทั้งหมดอยู่

แล้วทำไมโค้ดนี้ถึง "ยังไม่พร้อมใช้จริง"

โค้ดข้างบนรันได้ และถ้าคุณเป็น "loop engineer" ที่โฟกัสแค่วงจร คุณอาจคิดว่างานเสร็จแล้ว — แต่ลองดูสิ่งที่ ไม่มี ในนั้น ทุกข้อคือชิ้นอื่นของ harness ที่ยังหายไป:

• สิทธิ์และการจำกัด path (permission): read_file(**block.input) จะอ่าน report.txt ก็ได้ อ่าน ~/.ssh/id_rsa หรือ /etc/passwd ก็ได้ ถ้าโมเดลถูกหลอกให้ขอ ไม่มีใครห้าม — นี่คือเหตุผลที่ผมย้ำเรื่องรัน agent ใน sandbox การจำกัดว่ามันแตะอะไรได้ ไม่ได้อยู่ใน loop แต่อยู่ในชั้น permission
• การตรวจงาน (verification/hook): ไม่มีอะไรเช็กว่าบทสรุปที่โมเดลให้มา ตรงกับไฟล์จริงไหม มันจะมโนตัวเลขในสรุปก็ได้ การบังคับให้ agent ตรวจงานตัวเองก่อนจบเป็นงานของชั้น hook ไม่ใช่ loop
• การจัดบริบท (context): ถ้า report.txt ยาว 500 หน้า หรือ loop วน 200 รอบ บริบทจะบวมจนเกินหน้าต่างแล้วพัง — การบีบอัด/ตัดบริบทเป็นคนละเรื่องกับ while ลูป ผมเขียนไว้ในการจัดการ context budget
• log การตัดสินใจ (audit): โค้ดนี้ไม่บันทึกเลยว่ามันอ่านไฟล์ไหน ตอนไหน เพราะอะไร ในงานการเงิน/ความเสี่ยง คำถามแรกที่ผู้ตรวจถามคือ "ย้อนดูได้ไหมว่ามันทำอะไรไปบ้าง" — โค้ดนี้ตอบไม่ได้
• เบรกและงบ (loop guard/budget): เงื่อนไขหยุดมีแค่ "โมเดลเลิกเรียกเครื่องมือ" ถ้ามันวนแก้ของเดิมไม่เลิก หรือเผา token ไปเรื่อย ๆ ไม่มีตัวตัด

เห็นภาพไหมครับ — loop คือสิ่งที่ทำให้มัน "วิ่งเองได้" แต่ทุกอย่างที่ทำให้มัน "วิ่งอย่างปลอดภัยและเชื่อถือได้" อยู่นอก loop ถ้าคุณเก่งแค่ loop คุณจะสร้าง agent ที่ทำงานอัตโนมัติ...เข้าหากำแพงได้อย่างมีประสิทธิภาพมาก

ทำไมมันสำคัญกับเรา: ลองไล่เช็ก 5 ข้อนี้กับ agent ที่คุณ (หรือทีมคุณ) กำลังสร้าง ถ้าตอบได้แค่ "loop เสร็จแล้ว" แต่อีก 4 ข้อยังว่าง แปลว่าคุณเพิ่งทำ harness ไป 1 ใน 5 ชิ้น — ที่เหลือคือส่วนที่กันไม่ให้มันทำพัง

loop เก่งขึ้นไม่ได้ช่วย ถ้า harness รอบ ๆ ยังห่วย

มีประโยคจาก Addy Osmani (วิศวกรที่ Google) ที่ผมชอบมากคือ "a decent model with a great harness beats a great model with a bad harness" — โมเดลกลาง ๆ ใน harness ดี ๆ ชนะโมเดลเทพใน harness ห่วย ๆ หลักการเดียวกันนี้ใช้กับ loop ได้เป๊ะ: loop ที่ฉลาดแค่ไหน ก็ไม่ช่วย ถ้าเครื่องมือไม่คม สิทธิ์เปิดมั่ว บริบทจัดไม่เป็น และไม่มีใครตรวจงาน

ผมรวบรวมหลักฐานปี 2026 ที่ชี้ว่า "เปลี่ยนแค่ harness โดยไม่แตะโมเดล คะแนนก็กระโดดได้" ไว้ใน Agent Harness สำคัญพอ ๆ กับตัวโมเดล และเล่าว่าหลักการนี้ทำให้ผมเลือกเครื่องมือยังไงใน ทำไมผมเลือก Claude Code เพราะ harness จุดร่วมของทั้งสองเรื่องคือ อย่าตัดสินความเก่งของ agent จากชิ้นเดียว — ไม่ว่าจะเป็นตัวโมเดล หรือตัว loop

สรุป: เป็น harness engineer ไม่ใช่แค่ loop engineer

loop engineering เป็นทักษะจริงและควรทำให้เป็น — แต่มันคือ การขึ้นรูปชิ้นเดียวของ harness ถ้าเป้าหมายคือ agent ที่เอาไปใช้กับงานจริง โดยเฉพาะงานที่แตะเงินหรือข้อมูลสำคัญ สิ่งที่ตัดสินว่าคุณปลอดภัยหรือเปล่าไม่ได้อยู่ที่ while ลูปสวย ๆ แต่อยู่ที่คำถามว่า มันแตะอะไรได้บ้าง ใครอนุมัติ ตรวจย้อนหลังได้ไหม บริบทไม่หลุด และมีเบรกเมื่อไร — ซึ่งทั้งหมดอยู่นอก loop

ก็อปโค้ดข้างบนไปเล่นได้เลย มันคือ "the loop" ตัวจริง แล้วลองทำเป็นแบบฝึกหัด: เติมทีละชิ้นที่ขาด — จำกัด path, ใส่ log, ตัดบริบท, ใส่เพดาน token — คุณจะรู้สึกเองว่า loop เป็นส่วนที่เขียนเสร็จไวที่สุด ส่วนที่เหลือต่างหากคือ 'งาน' ถ้าอยากเห็นวิธีวางกระบวนการสร้างและ validate เครื่องมือ AI ทั้งระบบแบบที่ผมใช้กับงาน data จริง ผมรวมไว้ในคอร์ส Claude Code

ทำไมมันสำคัญกับเรา: ตำแหน่งที่มีค่าในทีมไม่ใช่ "คนที่เขียน loop เป็น" — เพราะนั่นใคร ๆ ก็ทำได้ในบ่ายเดียว แต่คือ "คนที่ออกแบบ harness ทั้งก้อนให้เชื่อถือได้และตรวจสอบได้" นั่นคือทักษะที่หายากและมีมูลค่าจริง