เวลาเราใช้ ChatGPT หรือ Claude ครั้งแรก — เราพิมพ์คำถาม ได้คำตอบ จบ
นั่นคือ LLM (Large Language Model) ในรูปแบบพื้นฐานที่สุด: ข้อความเข้า → ข้อความออก
แต่อยู่ ๆ มาวันหนึ่งเราเห็น AI ที่:
เราเติมอะไรลงไปบ้าง? — จาก chatbot ธรรมดากลายเป็น agent ได้ยังไง?
LLM คือ "เครื่องทำนายคำถัดไป" — มันเห็นข้อความก่อนหน้า แล้วเดาว่าคำต่อไปควรเป็นอะไร
[ผู้ใช้ถาม] → [LLM] → [คำตอบ]
สิ่งที่ LLM ทำไม่ได้ ในสภาพนี้:
มันคือสมองที่เก่ง — แต่ไม่มีแขน ไม่มีขา ไม่มีความจำ
สิ่งแรกที่เราเติม: system prompt — ข้อความที่บอก LLM ว่า "คุณเป็นใคร" และ "คุณทำอะไรได้บ้าง"
คุณคือ AI ผู้ช่วยชื่อ Hermes
คุณทำงานบนเครื่อง Linux ของผู้ใช้
คุณตอบเป็นภาษาไทย อ่านง่าย เป็นกันเอง
System prompt คือ "job description" ของ AI — มันเปลี่ยน LLM จาก "เครื่องทำนายคำ" เป็น "ผู้ช่วยที่มีตัวตน"
LLM เก่งเรื่องภาษา แต่มันกดเครื่องคิดเลขไม่เป็น — เราก็เลยให้ เครื่องมือ (tools) กับมัน
วิธีทำงาน:
1. ผู้ใช้: "เช็คสภาพอากาศกรุงเทพวันนี้"
2. LLM คิด: "ฉันต้องเรียกฟังก์ชัน get_weather(city='Bangkok')"
3. ระบบ: เรียก get_weather() จริง → ได้ผลลัพธ์ { temp: 35, humidity: 70 }
4. ระบบ: ส่งผลลัพธ์กลับไปให้ LLM
5. LLM: "วันนี้กรุงเทพ 35 องศา ความชื้น 70% ครับ"
Tools ที่เราให้ AI ได้:
| Tool | ตัวอย่าง | LLM ทำอะไร |
|---|---|---|
| Web search | search("ราคาทองวันนี้") |
|
| ค้นเน็ต | ||
| File read | read_file("config.yaml") |
|
| อ่านไฟล์ | ||
| Terminal | terminal("git status") |
|
| รันคำสั่ง | ||
| Database | query("SELECT * FROM users") |
|
| ถาม database |
สิ่งที่เปลี่ยน: LLM ไม่ได้แค่ "พูด" แล้ว — มัน "ทำ" ได้แล้ว
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 ไม่ได้ตอบทันทีแล้ว — มันใช้เวลา "ทำงาน" หลายวินาที หรือหลายนาที
Loop ช่วยให้ AI ทำงานต่อเนื่องใน session เดียว — แต่พอปิด session ทุกอย่างหายหมด
เราเติม memory — ระบบจดจำสิ่งที่เกิดขึ้นข้าม session:
Session 1: ผู้ใช้บอกว่า "ผมใช้ Go เป็นหลัก ชอบ pattern แบบนี้"
Session 2: AI ทักว่า "คราวที่แล้วคุณบอกว่าชอบ table-driven test — จะใช้ pattern นั้นไหม?" ← จำได้!
Memory เก็บอะไร:
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 ไม่ได้ตอบทันที แต่มัน "คิด" ก่อน — แล้วค่อยทำตามแผน
พอ AI ทำงานซ้ำ ๆ — เราอยากให้มัน "จำวิธีทำ" และใช้ซ้ำได้โดยไม่ต้องคิดใหม่ทุกครั้ง
เราเติม skills — ไฟล์ที่บรรจุ "วิธีการทำงานที่พิสูจน์แล้ว":
วิธีเช็คยอดเงิน DeepSeek:
1. อ่าน key จาก ~/.bashrc
2. เรียก curl https://api.deepseek.com/user/balance
3. แสดงผลเป็นภาษาไทย
คราวหน้าเวลา AI ต้องเช็คยอด — มันโหลด skill นี้ → ทำตามขั้นตอน → เสร็จใน 3 วิ — ไม่ต้องคิดใหม่
Skill = "ประสบการณ์ที่บันทึกไว้" — เหมือน SOP ขององค์กร
งานบางอย่างใหญ่มาก — 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 → โพสต์
ทำงานพร้อมกัน — เสร็จเร็วขึ้น — เหมือนมีทีมช่วย
เอา 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 ที่เติมเข้าไปเพิ่ม:
ทั้งหมดคือการเติม "layer" — และทั้งหมดเริ่มจาก LLM เปล่า ๆ ตัวเดียว
📚
อ่านต่อ:
[Aider — Pair Programming กับ AI ใน Terminal]— ตัวอย่าง agentic AI ที่ใช้จริง[Anthropic: Building effective agents]— แนวคิดการออกแบบ agentic system