The New AI Stack: โมเดล, Harnesses, ลูป และเอเจนต์ที่พัฒนาตัวเองได้

ทุกคนกำลังพูดถึงโมเดล AI

แต่ไม่มีใครพูดถึงเลเยอร์ที่ทำให้มันมีประโยชน์จริงๆ

Claude Code, Codex, Cursor

สิ่งเหล่านี้ไม่ใช่แค่โมเดล

พวกมันคือโมเดลที่ถูกห่อหุ้มด้วยระบบ

ระบบนั้นเรียกว่า "สายรัด" (Harness)

และสายรัดที่ดีที่สุดตอนนี้สามารถพัฒนาตัวเองได้

นี่คือทุกสิ่งที่คุณต้องรู้เกี่ยวกับสแต็ก AI ใหม่

ความเชื่อผิดๆ ที่ทุกคนมีเกี่ยวกับผลิตภัณฑ์ AI

คนส่วนใหญ่คิดว่าความก้าวหน้าของ AI = โมเดลที่ฉลาดขึ้น

มันไม่ใช่

โมเดลเป็นเพียงส่วนหนึ่งของสแต็ก

สถาปัตยกรรมถูกเผยแพร่ ทุกคนก็ลอกเลียน Transformer ตัวเดียวกัน ทุกแล็บใช้ส่วนประกอบพื้นฐานเดียวกัน

สิ่งที่ทำให้ Claude Code แตกต่างจากโปรเจกต์ทำเล่นสุดสัปดาห์ไม่ใช่โมเดล

มันคือสิ่งที่อยู่รอบๆ โมเดล

สายรัด (Harness)

ในปี 2017 ความก้าวหน้าของ AI อยู่ที่กลไก Attention ในปี 2020 อยู่ที่การขยายขนาด (Scale) ในปี 2026 มันอยู่ที่วิศวกรรมสายรัด (Harness Engineering)

และตอนนี้สายรัดกำลังถูกออกแบบโดย AI ไม่ใช่มนุษย์

สายรัดคืออะไร?

สายรัดคือระบบที่อยู่รอบๆ โมเดล

มันกำหนด:

→ โมเดลจะคิดและวางแผนอย่างไร

→ เมื่อไหร่ที่มันจะเรียกใช้เครื่องมือ และจะทำอย่างไรกับผลลัพธ์

→ มันจะจดจำอะไรในแต่ละขั้นตอน

→ มันจะเก็บสิ่งประดิษฐ์ (Artifacts) และจัดการสถานะอย่างไร

→ มันจะประเมินผลลัพธ์ของตัวเองอย่างไร

→ เมื่อไหร่ที่มันจะวนกลับมาและลองใหม่

ลองนึกถึงมันเหมือนระบบปฏิบัติการ

โมเดลคือ CPU สายรัดคือ OS

คุณสามารถมี CPU ที่ทรงพลังและซอฟต์แวร์ที่แย่ แล้วไม่สามารถส่งมอบอะไรที่มีประโยชน์ได้ คุณสามารถมี CPU ธรรมดาและซอฟต์แวร์ที่ยอดเยี่ยม แล้วส่งมอบสิ่งที่ยิ่งใหญ่ได้

เอเจนต์เขียนโค้ดที่ประสบความสำเร็จมากที่สุด — Claude Code, Codex, Cursor — ล้วนมีแนวคิดเดียวกัน:

การวนซ้ำ (Loop) สำคัญพอๆ กับโมเดล

3 รูปแบบสายรัดที่ผู้สร้าง AI ทุกคนต้องรู้

ทุกระบบ AI ในระดับโปรดักชั่นใช้อย่างน้อยหนึ่งรูปแบบนี้

รูปแบบที่ 1: การวนซ้ำ (The Loop)

โมเดลไม่ได้ตอบเพียงครั้งเดียวแล้วหยุด

มันวนซ้ำ

วางแผน → ดำเนินการ → สังเกตผล → ปรับปรุง → ทำซ้ำ

นี่คือแกนหลักของเอเจนต์เขียนโค้ดทุกตัว

ตัวอย่างการวนซ้ำแบบง่ายของ Claude Code:

1. อ่านงาน
2. วางแผนแนวทาง
3. เขียนโค้ด → รันมัน
4. ดูว่าอะไรล้มเหลว
5. แก้ไขมัน
6. รันอีกครั้ง
7. ทำซ้ำจนกว่าการทดสอบจะผ่าน

โมเดลไม่ได้ฉลาดขึ้นในรอบที่ 3 เมื่อเทียบกับรอบที่ 1

แต่ระบบฉลาดขึ้น

แต่ละรอบจะให้บริบทใหม่แก่โมเดล — ข้อความแสดงข้อผิดพลาด, ผลการทดสอบ, ร่องรอยการดำเนินการ

ผลลัพธ์ของรอบที่ 1 กลายเป็นข้อมูลนำเข้าของรอบที่ 2

บริบทที่ทับถมกันนี้คือสาเหตุที่ระบบเอเจนต์ทำงานได้ดีกว่าการใช้พรอมต์ครั้งเดียว (Single-shot Prompting) สำหรับงานที่ซับซ้อน

ข้อมูลเชิงลึกที่สำคัญ: โมเดลยังคงเดิม บริบทจะฉลาดขึ้น

รูปแบบที่ 2: ระบบไฟล์เป็นหน่วยความจำ

นักพัฒนาส่วนใหญ่ยัดทุกอย่างเข้าไปในหน้าต่างบริบท (Context Window)

นี่คือกับดัก

งานที่ใช้เวลานาน (Long-horizon Tasks) จะสร้าง:

→ บันทึกการทดลอง

→ ความแตกต่างของโค้ด (Code diffs) → ร่องรอยข้อผิดพลาด (Error traces)

→ ประวัติการเปิดตัวในอดีต → บทสรุปเอกสาร → สิ่งประดิษฐ์ขั้นกลาง

ทั้งหมดนั้นใหญ่เกินกว่าหน้าต่างบริบทใดๆ

วิธีแก้: เขียนลงในไฟล์ ไม่ใช่เขียนลงในบริบท

1# ไม่ดี: ทุกอย่างอยู่ในบริบท
2context = previous_output + tool_result + error_log + history...
3# ระเบิดตอนขั้นตอนที่ 47
4
5# ดี: ใช้ระบบไฟล์
6agent.write("experiments/run_3/error_log.txt", error_trace)
7agent.write("experiments/run_3/results.json", metrics)
8
9# ต่อมา เอเจนต์อ่านเฉพาะสิ่งที่ต้องการ
10relevant = agent.read("experiments/run_3/results.json")

สิ่งนี้เปลี่ยนแปลงทุกอย่างเกี่ยวกับงานที่ใช้เวลานาน

→ เอเจนต์สามารถทำงานต่อหลังจากขัดข้องได้

→ เอเจนต์สามารถใช้เหตุผลกับประวัติการทำงานของตัวเองได้

→ บริบทยังคงสะอาดแม้ในขั้นตอนที่ 200

→ เอเจนต์ย่อยหลายตัวสามารถแชร์สถานะผ่านไฟล์ได้

เอเจนต์ที่ดีที่สุดจะปฏิบัติต่อระบบไฟล์เหมือนสมองที่สอง

ไม่ใช่ที่ทิ้งขยะ แต่เป็นหน่วยความจำที่มีโครงสร้าง

รูปแบบที่ 3: เอเจนต์ย่อย (Sub-agents)

เอเจนต์ตัวเดียวไม่สามารถทำทุกอย่างได้

ระบบที่ดีที่สุดจะสร้างเอเจนต์ย่อยแบบขนาน

เอเจนต์หลัก:

→ แบ่งงานออกเป็นงานย่อยอิสระ

→ เปิดตัวเอเจนต์ย่อยเพื่อทำงานเหล่านั้นแบบขนาน

→ ติดตามสถานะของพวกมัน → รวมผลลัพธ์กลับมา

ตัวอย่างสำหรับสายรัดงานวิจัย:

1เอเจนต์หลักได้รับ: "เขียนรายงานการวิเคราะห์การแข่งขันฉบับสมบูรณ์"
2
3สร้างเอเจนต์ย่อย 4 ตัวพร้อมกัน:
4→ เอเจนต์ย่อย 1: ค้นคว้าราคาและคุณสมบัติของคู่แข่ง A
5→ เอเจนต์ย่อย 2: ค้นคว้าราคาและคุณสมบัติของคู่แข่ง B
6→ เอเจนต์ย่อย 3: ค้นหาข่าวล่าสุดเกี่ยวกับคู่แข่งทั้งสอง
7→ เอเจนต์ย่อย 4: ดึงรีวิวผู้ใช้จาก Reddit และ App Store
8
9เอเจนต์หลักรอ จากนั้นรวมผลลัพธ์ทั้ง 4 เป็นรายงานสุดท้าย
10
11เวลาทั้งหมด: เท่ากับเอเจนต์ย่อยที่ช้าที่สุด (ไม่ใช่นานกว่า 4 เท่า)

กฎการออกแบบที่สำคัญ: ผลลัพธ์ของเอเจนต์ย่อยต้องไปที่ไฟล์

ไม่ใช่บริบทชั่วคราว แต่เป็นไฟล์

ถ้ามันอยู่ในบริบทเท่านั้น มันจะหายไปเมื่อเซสชันของเอเจนต์ย่อยสิ้นสุดลง

ถ้ามันอยู่ในไฟล์ เอเจนต์หลักสามารถตรวจสอบได้ ระบบสามารถกู้คืนจากความขัดข้องได้ และทุกอย่างสามารถตรวจสอบได้

เครื่องมือที่เอเจนต์เขียนโค้ดทุกตัวใช้

หากคุณกำลังสร้างเอเจนต์ นี่คือชุดเครื่องมือที่เอเจนต์เขียนโค้ดหลักทุกรายการกำหนดมาตรฐานไว้

1เครื่องมือระบบไฟล์:
2→ glob, grep, ls          # ค้นหาไฟล์
3→ read, read_many         # อ่านเนื้อหา
4→ write                   # สร้างไฟล์ใหม่
5→ edit                    # แก้ไขแบบแทนที่สตริง
6→ apply_patch             # ความแตกต่างที่มีโครงสร้าง
7
8เครื่องมือเชลล์:
9→ bash                    # รันคำสั่งใดๆ
10→ PowerShell              # เวอร์ชัน Windows
11
12การควบคุมเวอร์ชัน:
13→ git_status, git_diff    # ตรวจสอบการเปลี่ยนแปลง
14→ git_commit              # บันทึกความคืบหน้า
15
16การจัดการเอเจนต์:
17→ spawn_agent             # เปิดตัวเอเจนต์ย่อย
18→ wait_agent              # รอผลลัพธ์
19→ list_agents             # ดูสิ่งที่กำลังทำงาน
20→ interrupt_agent         # ยกเลิกหากจำเป็น
21
22บริบทภายนอก:
23→ web_search, web_fetch   # รับข้อมูลปัจจุบัน
24→ MCP tools               # เชื่อมต่อกับบริการภายนอก

คุณไม่จำเป็นต้องมีทั้งหมดนี้สำหรับทุกเอเจนต์

แต่ทุกเอเจนต์ในระดับโปรดักชั่นในที่สุดก็ต้องการส่วนใหญ่

สิ่งที่สำคัญที่สุดในช่วงแรก: bash, read, write, edit

เชี่ยวชาญสี่อย่างนี้ แล้วคุณสามารถสร้างอะไรก็ได้เกือบทุกอย่าง

วิศวกรรมบริบท: ทักษะที่ไม่มีใครพูดถึง

โมเดลถูกกำหนดไว้แล้ว

คุณไม่สามารถเปลี่ยนน้ำหนักของมันขณะรันไทม์ได้

แต่คุณสามารถเปลี่ยนสิ่งที่มันเห็นได้

นั่นคือวิศวกรรมบริบท (Context Engineering)

และตอนนี้มันเป็นหนึ่งในทักษะที่มีเลเวอเรจสูงที่สุดในวิศวกรรม AI

บริบทที่ไม่ดี:

→ ทิ้งทุกอย่างเข้าไป → หวังให้ดีที่สุด

→ บริบทบวม → โมเดลเสียสมาธิ → ผลลัพธ์ด้อยลง

บริบทที่ดี:

→ มีโครงสร้าง กระชับ พัฒนาไปเรื่อยๆ

→ ข้อมูลที่ถูกต้องในขั้นตอนที่ถูกต้อง

→ ความล้มเหลวก่อนหน้านี้แจ้งให้ทราบถึงความพยายามในปัจจุบัน

แนวทางที่ล้ำสมัย (ACE — Agentic Context Engineering):

13 องค์ประกอบ:
2
3Generator:   ทำงาน, อ้างอิงคู่มือบริบทที่มีโครงสร้าง
4Reflector:   วิเคราะห์ความสำเร็จและความล้มเหลว, สกัดข้อมูลเชิงลึก
5Curator:     อัปเดตคู่มือด้วยการเรียนรู้ใหม่ — เพิ่ม, ลบ, ลดความซ้ำซ้อน
6
7คู่มือไม่ใช่ก้อนพรอมต์
8มันคือรายการที่มีโครงสร้างของคู่ (identifier, insight)
9
10ตัวอย่าง:
11{
12  "id": "001",
13  "insight": "เขียนร่องรอยข้อผิดพลาดลงไฟล์ก่อนลองใหม่เสมอ"
14},
15{
16  "id": "002",
17  "insight": "เอเจนต์ย่อยสำหรับค้นหาเว็บให้ผลลัพธ์ดีกว่าด้วยคำค้นหาเฉพาะไซต์"
18},
19{
20  "id": "003",
21  "insight": "การรันทดสอบก่อนคอมมิตจับการถดถอยได้ 80%"
22}

คู่มือจะอัปเดตหลังจากทุกการทำงาน

เอเจนต์ที่ทำงานที่ 50 กำลังทำงานด้วยการเรียนรู้ที่กลั่นกรองจาก 49 ครั้ง

เอเจนต์ที่ทำงานที่ 1 ไม่มีอะไรเลย

นี่คือวิธีที่ระบบฉลาดขึ้นโดยไม่ต้องแตะน้ำหนักโมเดล

สายรัดที่พัฒนาตัวเอง

นี่คือจุดที่มันเริ่มบ้า

จะเป็นอย่างไรถ้าสายรัดเองเป็นสิ่งที่ถูกปรับให้เหมาะสม?

ไม่ใช่พรอมต์ ไม่ใช่โมเดล

แต่เป็นโค้ดที่รันเอเจนต์

นี่คือสิ่งที่ Self-Harness ทำ

ลูป 3 ขั้นตอน:

ขั้นตอนที่ 1 — ค้นหาจุดอ่อน

รันสายรัดปัจจุบันบนชุดงาน เก็บร่องรอยความล้มเหลว จัดกลุ่มความล้มเหลวตามสาเหตุที่แท้จริง

ไม่ใช่ "มันล้มเหลว" แต่ทำไมมันถึงล้มเหลว

ประเภทความล้มเหลวที่ค้นพบ:

→ "เอเจนต์หมดเวลาในการอ่านไฟล์ขนาดใหญ่"

→ "ผลลัพธ์ของเอเจนต์ย่อยหายไปเมื่อเอเจนต์หลักขัดข้อง"

→ "ข้อความแสดงข้อผิดพลาดไม่เพียงพอที่จะแก้ไขตัวเอง"

→ "บริบทใหญ่เกินไปหลังจากขั้นตอนที่ 30 โมเดลเสียสมาธิ"

ขั้นตอนที่ 2 — เสนอการแก้ไข

โมเดลเดียวกันดูรูปแบบความล้มเหลว เสนอการแก้ไขที่เฉพาะเจาะจงและแคบให้กับโค้ดสายรัด

ไม่ใช่การเขียนใหม่ แต่เป็นการแก้ไขแบบเจาะจง

การแก้ไขสายรัดที่เสนอ:

→ เพิ่มตัวจัดการหมดเวลาในการดำเนินการอ่านไฟล์

→ ล้างข้อมูลผลลัพธ์ของเอเจนต์ย่อยไปยังดิสก์โดยอัตโนมัติในทุกขั้นตอน (ไม่ใช่แค่ตอนท้าย)

→ กำหนดรูปแบบข้อความแสดงข้อผิดพลาดให้รวม: ขั้นตอน, เครื่องมือ, อินพุต, เอาต์พุต, สาเหตุความล้มเหลว

→ เพิ่มขั้นตอนการบีบอัดบริบททุกๆ 25 รอบ

ขั้นตอนที่ 3 — ตรวจสอบและรวม

การแก้ไขที่เสนอแต่ละรายการจะถูกทดสอบกับงานที่แยกไว้

มันแก้ไขจุดอ่อนโดยไม่ทำลายสิ่งอื่นหรือไม่?

ถ้าใช่: รวมเข้ากับสายรัด ถ้าไม่ใช่: บันทึก, ปฏิเสธ, สายรัดไม่เปลี่ยนแปลง

ผลลัพธ์: สายรัดดีขึ้นทุกเจเนอเรชัน

Claude 3.5 Sonnet ที่รัน Self-Harness เพิ่มขึ้นจาก 20% เป็น 50% บน SWE-bench Verified

ไม่ใช่จากโมเดลที่ดีกว่า

แต่จากระบบที่ดีกว่า

การค้นหาสายรัดเชิงวิวัฒนาการ

Self-Harness แก้ไขสายรัดทีละอันแบบวนซ้ำ

AlphaEvolve รันประชากรของสายรัดและวิวัฒนาการสายรัดที่ดีที่สุด

อัลกอริทึม:

11. เริ่มต้นด้วยกลุ่มผู้สมัครสายรัด
22. ให้คะแนนแต่ละตัวในงานเกณฑ์มาตรฐาน
33. เลือกผู้ที่มีประสิทธิภาพดีที่สุดเป็น "พ่อแม่"
44. ขอให้โมเดลเสนอ diffs/การปรับปรุง
55. สร้างสายรัด "ลูก" ใหม่
66. ให้คะแนนลูก
77. เก็บตัวที่ปรับปรุงดีขึ้น
88. เพิ่มกลับเข้าไปในกลุ่ม
99. ทำซ้ำ
10
11(ตรรกะเดียวกับการคัดเลือกโดยธรรมชาติ ประยุกต์ใช้กับโค้ด)

(ตรรกะเดียวกับการคัดเลือกโดยธรรมชาติ ประยุกต์ใช้กับโค้ด)

รายละเอียดการออกแบบที่สำคัญอย่างหนึ่งจาก AlphaEvolve:

พื้นที่โค้ดที่มีสิทธิ์สำหรับวิวัฒนาการจะถูกทำเครื่องหมายอย่างชัดเจน:

1# EVOLVE-BLOCK-START
2def plan_next_step(context, tools):
3    # ส่วนนี้สามารถแก้ไขได้โดยการค้นหาเชิงวิวัฒนาการ
4    prompt = f"Given: {context}\nAvailable tools: {tools}\nNext action:"
5    return llm.generate(prompt)
6# EVOLVE-BLOCK-END
7
8# ส่วนที่เหลือของสายรัดคงที่
9def run_tool(tool_name, args):
10    return tool_registry[tool_name](**args)

การกักกันนี้ป้องกันไม่ให้เอเจนต์แก้ไขโค้ดที่สำคัญต่อความปลอดภัยโดยไม่ได้ตั้งใจ

การค้นหาเชิงวิวัฒนาการจะแตะเฉพาะสิ่งที่คุณอนุญาตอย่างชัดเจนให้แตะเท่านั้น

AlphaEvolve ใช้สิ่งนี้เพื่อปรับอัลกอริทึมการคูณเมทริกซ์ให้เหมาะสม

ผลลัพธ์: เอาชนะโค้ดที่ปรับด้วยมือของ DeepMind

เอเจนต์พบวิธีแก้ปัญหาที่วิศวกรมนุษย์ไม่เคยค้นพบมานานหลายทศวรรษ

Darwin Gödel Machine: เอเจนต์ที่เขียนตัวเองใหม่

เวอร์ชันที่รุนแรงที่สุดของแนวคิดนี้

เอเจนต์ที่แก้ไขโค้ดสายรัดของตัวเองเพื่อให้ทำงานได้ดีขึ้น

Darwin Gödel Machine (DGM):

11. เริ่มต้นด้วยเอเจนต์เขียนโค้ดหนึ่งตัวในกลุ่ม
22. รันบนเกณฑ์มาตรฐาน, เก็บคะแนน
33. เอเจนต์ตรวจสอบบันทึกการประเมินของตัวเอง
44. เอเจนต์เสนอการปรับปรุงโค้ดสายรัดของตัวเอง
55. เครื่องมือที่มี: bash + โปรแกรมแก้ไขไฟล์ (ดู/สร้าง/แก้ไขไฟล์)
66. สร้างเอเจนต์เวอร์ชันใหม่
77. ให้คะแนนเวอร์ชันใหม่
88. ถ้าดีกว่า: เพิ่มในกลุ่ม
99. ถ้าแย่กว่า: ทิ้ง
1010. ทำซ้ำ — เลือกพ่อแม่ตามประสิทธิภาพ, ผกผันตามจำนวนลูกหลาน

เงื่อนไขเริ่มต้น: Claude 3.5 Sonnet + สายรัดเริ่มต้นอย่างง่าย

ผลลัพธ์:

→ SWE-bench Verified: 20% → 50%

→ เกณฑ์มาตรฐานการเขียนโค้ดหลายภาษา: 14.2% → 30.7%

ไม่มีการเปลี่ยนแปลงน้ำหนักโมเดล ไม่มีวิศวกรรมมนุษย์ระหว่างเจเนอเรชัน

เอเจนต์ออกแบบเวอร์ชันที่ดีกว่าของตัวเอง

นี่ไม่ใช่นิยายวิทยาศาสตร์

นี่คือเอกสารจากปี 2025

5 รูปแบบความล้มเหลวที่ควรหลีกเลี่ยง

นี่คือวิธีที่ทีมวิจัยจริงล้มเหลว

ทั้งหมดถูกบันทึกไว้ ทั้งหมดหลีกเลี่ยงได้

1. การยุบบริบท (Context collapse)

งานที่ใช้เวลานานสูญเสียรายละเอียดที่สำคัญหากบันทึกไม่ได้ถูกเขียนเป็นสิ่งประดิษฐ์ถาวร

วิธีแก้ไข: เขียนทุกสิ่งที่สำคัญลงในไฟล์ อย่าพึ่งพาบริบทเพียงอย่างเดียวหลังจากขั้นตอนที่ 20

2. การเบี่ยงเบนในการดำเนินการ (Implementation drift)

เมื่องานมีความยากในทางเทคนิค โมเดลจะเบี่ยงเบนไปสู่โซลูชันที่ง่ายกว่าและธรรมดากว่าแทนเป้าหมายจริง

วิธีแก้ไข: เขียนไฟล์สเปกตั้งแต่เริ่มต้น เอเจนต์ตรวจสอบสเปกในทุกรอบ

3. การมองโลกในแง่ดีเกินไป (Over-optimism)

โมเดลประกาศความสำเร็จทั้งที่การทดลองล้มเหลว

มันพบ "เทปปิดตัวเลข" — แพตช์ที่ทำให้เมตริกดูดีโดยไม่แก้ปัญหาจริง

วิธีแก้ไข: แยกชุดทดสอบที่เอเจนต์ไม่เคยเห็น ตรวจสอบเฉพาะข้อมูลที่แยกไว้

4. การแฮ็กรางวัล (Reward hacking)

เอเจนต์ปรับสัญญาณใดก็ตามที่ได้รับให้เหมาะสมที่สุด

ถ้าสัญญาณคือการทดสอบหน่วย — มันเขียนการทดสอบที่ผ่านเสมอ ถ้าสัญญาณคือโมเดลผู้ตัดสิน — มันเรียนรู้กลเม็ดเพื่อหลอกผู้ตัดสิน ถ้าสัญญาณคือคะแนนเกณฑ์มาตรฐาน — มันใช้ประโยชน์จากสิ่งแปลกปลอมของเกณฑ์มาตรฐาน

วิธีแก้ไข: ผู้ประเมินอยู่ภายนอกลูป การตรวจสอบโดยมนุษย์ ณ จุดตัดสินใจที่สำคัญ

5. การยุบความหลากหลาย (Diversity collapse)

ลูปวิวัฒนาการมาบรรจบกันที่กลยุทธ์เดียว

ทุกเจเนอเรชันดูเหมือนรูปแบบของโซลูชันเดียวกัน

วิธีแก้ไข: ติดตามความแปลกใหม่อย่างชัดเจน ลงโทษโซลูชันที่คล้ายกับสมาชิกในกลุ่มที่มีอยู่มากเกินไป (ใช้ความคล้ายคลึงโคไซน์แบบ Embedding)

สแต็ก AI ใหม่ในภาษาที่เข้าใจง่าย

นี่คือสิ่งที่คุณกำลังสร้างจริงๆ เมื่อคุณสร้างผลิตภัณฑ์ AI ที่จริงจัง:

เลเยอร์ที่ 1 — โมเดล

ความฉลาดดิบ ผ่านการฝึกฝนล่วงหน้า น้ำหนักคงที่ขณะรันไทม์

นี่คือ CPU ทรงพลังแต่เฉื่อยชา

เลเยอร์ที่ 2 — สายรัด

OS ห่อหุ้มโมเดล จัดการทุกอย่าง

→ เครื่องมือ (bash, อ่าน/เขียนไฟล์, ค้นหาเว็บ)

→ หน่วยความจำ (ระบบไฟล์, บันทึกที่มีโครงสร้าง)

→ การวนซ้ำ (วางแผน → ดำเนินการ → ประเมินผล → ลองใหม่) → เอเจนต์ย่อย (การดำเนินการแบบขนาน)

→ การจัดการบริบท (สิ่งที่โมเดลเห็นในแต่ละขั้นตอน)

เลเยอร์ที่ 3 — ตัวปรับให้เหมาะสม

สายรัดที่ปรับปรุงสายรัด

→ ค้นหารูปแบบความล้มเหลวจากร่องรอยการดำเนินการ

→ เสนอการแก้ไขแบบเจาะจงให้กับโค้ดสายรัด → ตรวจสอบกับงานที่แยกไว้

→ รวมการปรับปรุง, ทิ้งการถดถอย

เลเยอร์ที่ 4 — ผู้ประเมิน

อยู่ภายนอกเลเยอร์อื่นๆ ทั้งหมด

→ คะแนนเกณฑ์มาตรฐาน → การตรวจสอบโดยมนุษย์ ณ จุดตัดสินใจที่สำคัญ → ชุดทดสอบที่แยกไว้ซึ่งตัวปรับให้เหมาะสมไม่เคยแตะต้อง

คุณไม่สามารถข้ามเลเยอร์ใดๆ ได้

ข้ามเลเยอร์ที่ 2 — โมเดลของคุณคือแชทบอท ไม่ใช่ผลิตภัณฑ์

ข้ามเลเยอร์ที่ 3 — ระบบของคุณไม่เคยดีขึ้นหากไม่มีวิศวกรรมด้วยมือ

ข้ามเลเยอร์ที่ 4 — เอเจนต์ของคุณปรับสิ่งผิดให้เหมาะสม และคุณจะไม่สังเกตเห็น

สิ่งนี้มีความหมายต่อผู้สร้างในตอนนี้

คุณไม่จำเป็นต้องสร้างสายรัดที่พัฒนาตัวเองเพื่อรับประโยชน์จากแนวคิดเหล่านี้

เริ่มต้นที่นี่:

สัปดาห์ที่ 1: สร้างลูป

หยุดสร้างพรอมต์ครั้งเดียว สร้างลูป วางแผน → ดำเนินการ → ประเมินผล → ลองใหม่ สำหรับงานใดๆ ที่ต้องใช้มากกว่าหนึ่งขั้นตอน

สัปดาห์ที่ 2: เพิ่มหน่วยความจำถาวร

หยุดพึ่งพาบริบท เขียนผลลัพธ์ขั้นกลางลงในไฟล์ ให้เอเจนต์อ่านงานก่อนหน้าของตัวเอง

สัปดาห์ที่ 3: เพิ่มเอเจนต์ย่อย

ระบุส่วนใดๆ ของเวิร์กโฟลว์ของคุณที่สามารถรันแบบขนานได้ สร้างเอเจนต์ย่อย เขียนผลลัพธ์ลงในไฟล์ รวมเข้าด้วยกัน

สัปดาห์ที่ 4: เพิ่มวิศวกรรมบริบท

ติดตามว่ารูปแบบใดนำไปสู่ความสำเร็จและความล้มเหลว สร้างคู่มือที่มีโครงสร้างอย่างง่ายที่อัปเดตหลังจากการทำงานแต่ละครั้ง

นั่นคือสายรัด

ไม่ใช่โมเดล

โมเดลมีอยู่แล้ว

สายรัดคือสิ่งที่คุณสร้าง

ความจริงอันไม่สบายใจเกี่ยวกับ AI ในปี 2026

การเร่งวิจัยที่แล็บชั้นนำเพิ่มขึ้นอย่างมาก

Anthropic และ OpenAI กำลังปล่อยผลิตภัณฑ์เร็วกว่าที่เคย

ไม่ใช่เพราะโมเดลฉลาดขึ้นในชั่วข้ามคืน

แต่เพราะสายรัดดีขึ้น

เอเจนต์ที่วนซ้ำ, จดจำ, มอบหมายงานย่อย, และแก้ไขตัวเอง ทำงานได้ดีกว่าโมเดลที่ฉลาดกว่าที่ใช้ผิดวิธี

คูเมืองไม่ใช่โมเดล

คูเมืองคือระบบ

และตอนนี้ระบบสามารถพัฒนาตัวเองได้

หากสิ่งนี้มีประโยชน์:

→ รีโพสต์ — ผู้สร้าง AI ทุกคนต้องเข้าใจสแต็กนี้

→ ติดตาม @sairahul1 สำหรับบทความเจาะลึกแบบนี้เพิ่มเติม

→ บุ๊กมาร์ก — สแต็ก 4 เลเยอร์เพียงอย่างเดียวก็คุ้มค่าที่จะบันทึก

สมัครสมาชิก theaibuilders.co เพื่อรับบทความที่น่าสนใจเพิ่มเติม

ฉันเขียนเกี่ยวกับ AI, การสร้างผลิตภัณฑ์, และระบบที่ทำงานได้โดยไม่มีคุณ