จาก chatbot ธรรมดา สู่ AI ที่ทำงานแทนเราได้ — เราเติมอะไรเข้าไปบ้าง?

จาก chatbot ธรรมดา สู่ AI ที่ทำงานแทนเราได้ — เราเติมอะไรเข้าไปบ้าง?

เวลาเราใช้ ChatGPT หรือ Claude ครั้งแรก — เราพิมพ์คำถาม ได้คำตอบ จบ

นั่นคือ LLM (Large Language Model) ในรูปแบบพื้นฐานที่สุด: ข้อความเข้า → ข้อความออก

แต่อยู่ ๆ มาวันหนึ่งเราเห็น AI ที่:

• เข้าเว็บหาข้อมูลให้


• อ่านไฟล์ในเครื่องเรา


• รันคำสั่ง terminal


• เขียนโค้ด สร้างไฟล์ รัน test


• ทำงานต่อเนื่องเป็นสิบนาทีโดยไม่ต้องคอยบอกทุกขั้นตอน

เราเติมอะไรลงไปบ้าง? — จาก chatbot ธรรมดากลายเป็น agent ได้ยังไง?

🧱 เริ่มจาก LLM เปล่า ๆ

LLM คือ "เครื่องทำนายคำถัดไป" — มันเห็นข้อความก่อนหน้า แล้วเดาว่าคำต่อไปควรเป็นอะไร

[ผู้ใช้ถาม] → [LLM] → [คำตอบ]

สิ่งที่ LLM ทำไม่ได้ ในสภาพนี้:

• จำว่าเมื่อวานเราคุยอะไรกัน (ไม่มี memory)


• ค้นหาข้อมูลในเน็ต (ไม่มี tool)


• รู้วันที่วันนี้ (ถูก train ด้วยข้อมูลเก่า)


• ทำอะไรบนเครื่องเรา (ไม่มีสิทธิ์)

มันคือสมองที่เก่ง — แต่ไม่มีแขน ไม่มีขา ไม่มีความจำ

➕ Layer 1: System Prompt — ใส่ "บทบาท" และ "กติกา"

สิ่งแรกที่เราเติม: system prompt — ข้อความที่บอก LLM ว่า "คุณเป็นใคร" และ "คุณทำอะไรได้บ้าง"

คุณคือ AI ผู้ช่วยชื่อ Hermes

คุณทำงานบนเครื่อง Linux ของผู้ใช้

คุณตอบเป็นภาษาไทย อ่านง่าย เป็นกันเอง

System prompt คือ "job description" ของ AI — มันเปลี่ยน LLM จาก "เครื่องทำนายคำ" เป็น "ผู้ช่วยที่มีตัวตน"

➕ Layer 2: Tool Calling — ใส่ "แขน" และ "ขา"

LLM เก่งเรื่องภาษา แต่มันกดเครื่องคิดเลขไม่เป็น — เราก็เลยให้ เครื่องมือ (tools) กับมัน

วิธีทำงาน:

1. ผู้ใช้: "เช็คสภาพอากาศกรุงเทพวันนี้"

2. LLM คิด: "ฉันต้องเรียกฟังก์ชัน get_weather(city='Bangkok')"

3. ระบบ: เรียก get_weather() จริง → ได้ผลลัพธ์ { temp: 35, humidity: 70 }

4. ระบบ: ส่งผลลัพธ์กลับไปให้ LLM

5. LLM: "วันนี้กรุงเทพ 35 องศา ความชื้น 70% ครับ"

Tools ที่เราให้ AI ได้:

สิ่งที่เปลี่ยน: LLM ไม่ได้แค่ "พูด" แล้ว — มัน "ทำ" ได้แล้ว

➕ Layer 3: Loop — ใส่ "ความต่อเนื่อง"

tool ครั้งเดียวอาจไม่พอ — LLM อาจต้องเรียก tool หลายรอบเพื่อทำงานชิ้นหนึ่งให้เสร็จ

1. ผู้ใช้: "สร้างไฟล์ README.md ให้ project นี้"



2. LLM → tool: read_file("main.go")     ← อ่านก่อนว่ามีอะไร

3. LLM → tool: search_files("*.go")      ← หาไฟล์ทั้งหมด

4. LLM → tool: read_file("go.mod")       ← อ่าน module name

5. LLM → tool: write_file("README.md")   ← เขียน!

6. LLM → ผู้ใช้: "สร้าง README.md เสร็จแล้วครับ"

นี่คือ Agent Loop — วงจร "คิด → เรียก tool → ดูผล → คิดต่อ → เรียก tool อีก" — ไปเรื่อย ๆ จนกว่างานจะเสร็จ

💡 สังเกต: ตอนนี้ LLM ไม่ได้ตอบทันทีแล้ว — มันใช้เวลา "ทำงาน" หลายวินาที หรือหลายนาที

➕ Layer 4: Memory — ใส่ "ความจำ"

Loop ช่วยให้ AI ทำงานต่อเนื่องใน session เดียว — แต่พอปิด session ทุกอย่างหายหมด

เราเติม memory — ระบบจดจำสิ่งที่เกิดขึ้นข้าม session:

Session 1: ผู้ใช้บอกว่า "ผมใช้ Go เป็นหลัก ชอบ pattern แบบนี้"

Session 2: AI ทักว่า "คราวที่แล้วคุณบอกว่าชอบ table-driven test — จะใช้ pattern นั้นไหม?" ← จำได้!

Memory เก็บอะไร:

• ข้อมูลผู้ใช้ (ชื่อ, preference, ภาษาที่ชอบ)


• ข้อตกลงที่เคยทำไว้ ("ไม่ publish blog โดยไม่ขอ")


• วิธีการทำงานที่เคยสำเร็จ ("เวลาใช้ LED ต้องกด button.click()")

➕ Layer 5: Planning & Reasoning — ใส่ "การคิดก่อนทำ"

LLM เก่งเรื่องตอบคำถาม — แต่เวลาเจองานซับซ้อน มันอาจ "ทำเลย" โดยไม่คิดก่อน

เราเติม reasoning — บังคับให้ AI "คิดดัง ๆ" ก่อนลงมือ:

ผู้ใช้: "หา condo ในกรุงเทพ ราคา 7-8 ล้าน ขนาด ≥60 ตรม."



AI คิด (reasoning):

"1. ต้องเข้าเว็บ led.go.th

 2. กรอกฟอร์ม: ประเภท=ห้องชุด, จังหวัด=กรุงเทพ, ราคา=7-8M, ขนาด≥60

 3. แต่เว็บมี CAPTCHA — ต้องอ่าน CAPTCHA ทีหลังสุด

 4. ต้องใช้ button.click() — form.submit() ใช้ไม่ได้

 5. ถ้าไม่มีในห้วยขวาง → ขยายเป็นทั้งกรุงเทพ"



AI ลงมือทำตามแผน → สำเร็จ

นี่คือ reasoning — AI ไม่ได้ตอบทันที แต่มัน "คิด" ก่อน — แล้วค่อยทำตามแผน

➕ Layer 6: Skills — ใส่ "ประสบการณ์"

พอ AI ทำงานซ้ำ ๆ — เราอยากให้มัน "จำวิธีทำ" และใช้ซ้ำได้โดยไม่ต้องคิดใหม่ทุกครั้ง

เราเติม skills — ไฟล์ที่บรรจุ "วิธีการทำงานที่พิสูจน์แล้ว":

# Skill: deepseek-balance

วิธีเช็คยอดเงิน DeepSeek:

1. อ่าน key จาก ~/.bashrc

2. เรียก curl https://api.deepseek.com/user/balance

3. แสดงผลเป็นภาษาไทย

คราวหน้าเวลา AI ต้องเช็คยอด — มันโหลด skill นี้ → ทำตามขั้นตอน → เสร็จใน 3 วิ — ไม่ต้องคิดใหม่

Skill = "ประสบการณ์ที่บันทึกไว้" — เหมือน SOP ขององค์กร

➕ Layer 7: Multi-Agent — ใส่ "ทีม"

งานบางอย่างใหญ่มาก — AI ตัวเดียวทำงานไม่ทัน

เราเติม delegation — AI spawn ลูกน้องไปทำงานย่อย:

[AI หลัก] → "งานนี้มี 3 อย่าง: 1) research Go 1.27, 2) เขียน blog, 3) โพสต์"

           → spawn subagent 1: research Go 1.27

           → spawn subagent 2: ออกแบบโครงสร้าง blog

           → รอผล → เขียน blog → โพสต์

ทำงานพร้อมกัน — เสร็จเร็วขึ้น — เหมือนมีทีมช่วย

🧩 ประกอบร่าง — Agentic AI

เอา Layer ทั้งหมดมารวมกัน:

LLM เปล่า

  + System Prompt        → มี "ตัวตน"

  + Tool Calling         → มี "มือ" ทำงานได้

  + Loop                 → ทำงานต่อเนื่อง ไม่ใช่ตอบทีเดียวจบ

  + Memory               → จำได้ข้าม session

  + Reasoning            → คิดก่อนทำ

  + Skills               → ใช้ประสบการณ์ซ้ำ

  + Multi-Agent          → มีทีมช่วย

─────────────────────────────────────

  = Agentic AI

Agentic AI ไม่ได้ฉลาดกว่า LLM — มันแค่มี "เครื่องมือ" มากกว่า และถูกออกแบบให้ "ทำงาน" ไม่ใช่แค่ "ตอบ"

🎯 สรุปให้เห็นภาพ

           ┌──────────────────────────┐

           │      User: "สร้าง API"    │

           └──────────┬───────────────┘

                      ▼

           ┌──────────────────────────┐

           │   System Prompt: กติกา    │  ← "คุณเป็น dev ที่ใช้ Go"

           └──────────┬───────────────┘

                      ▼

           ┌──────────────────────────┐

           │      Reasoning: คิดก่อน    │  ← "ต้องสร้าง handler, service, repo"

           └──────────┬───────────────┘

                      ▼

     ┌────────────────┼────────────────┐

     ▼                ▼                ▼

┌─────────┐    ┌──────────┐    ┌──────────┐

│  Tool   │    │   Tool   │    │   Tool   │

│  อ่าน    │    │  เขียน    │    │   รัน     │

│  โค้ด    │    │  ไฟล์     │    │  test    │

└────┬────┘    └────┬─────┘    └────┬─────┘

     │              │               │

     └──────────────┼───────────────┘

                    ▼

           ┌──────────────────────────┐

           │  Loop: ทำซ้ำจนกว่าจะเสร็จ   │

           └──────────┬───────────────┘

                      ▼

           ┌──────────────────────────┐

           │  Memory: บันทึกสิ่งที่เรียนรู้    │  ← "คราวหน้าใช้วิธีนี้"

           └──────────────────────────┘

ต่อไปจากนี้

พอเข้าใจตรงนี้แล้ว — เวลาอ่านเรื่อง MCP (Model Context Protocol), ACP (Agent Client Protocol), RAG (Retrieval-Augmented Generation) — คุณจะเห็นว่ามันคือ layer ที่เติมเข้าไปเพิ่ม:

• MCP = วิธี standard ในการให้ tool กับ AI


• RAG = วิธีให้ AI "อ่านเอกสาร" ก่อนตอบ


• ACP = วิธี standard ในการคุยระหว่าง IDE กับ agent

ทั้งหมดคือการเติม "layer" — และทั้งหมดเริ่มจาก LLM เปล่า ๆ ตัวเดียว

📚 อ่านต่อ:

• 
  — แนวคิดการออกแบบ agentic system