สร้าง AI Agent ให้ทำงานได้หลายสเต็ปด้วย Python แค่ 9 บรรทัด ฟังดูเหมือนเป็นไปไม่ได้ แต่มันมีอยู่จริงในไฟล์ agent.py จาก Gist บน GitHub ในชื่อ agent in 9 lines python แถมถ้านับบรรทัดโค้ดจริงๆ ก็มี 9 บรรทัดพอดีเป๊ะ

เรามักติดภาพว่าถ้าจะทำ AI Agent ต้องพึ่งเฟรมเวิร์กใหญ่ๆ อย่าง LangChain แต่โค้ด 9 บรรทัดนี้ช่วยให้เห็นภาพชัดขึ้น เพราะแกนแท้จริงของ Agent ไม่ได้ซับซ้อนอะไรเลย ทั้งหมดคือลูปสั้นๆ ที่ปล่อยให้โมเดลประมวลผล ขอหยิบเครื่องมือมาใช้ แล้วดึงผลลัพธ์ที่ได้กลับมาคิดต่อ วนซ้ำไปเรื่อยๆ จนกว่าจะได้คำตอบสุดท้าย ซึ่งโค้ดชุดนี้มาจาก Gist ที่ผู้ใช้ GitHub ชื่อ tosh โพสต์ไว้ และแพร่ออกมาจากโพสต์บน Hacker News

AI Agent ต่างจากแชตบอตธรรมดาตรงไหน

แชตบอตทั่วไปที่เราคุ้นเคยมักจะตอบคำถามจบในรอบเดียว คาดเดาคำตอบจากสิ่งที่เคยเรียนรู้มาแล้วพิมพ์ตอบกลับทันที แต่ AI Agent ทำได้มากกว่านั้น เพราะทำงานเองได้หลายสเต็ป ตั้งแต่สั่งรันคำสั่ง เฝ้าดูผลลัพธ์จริง แล้วเอาผลที่ได้ไปตัดสินใจต่อในสเต็ปถัดไป

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

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

แกนสำคัญมีแค่ลูปเดียว

พอเข้าใจบทบาทของ tool แล้ว แกนหลักของ Agent ก็เหลือเพียงลูปสั้นๆ ลูปเดียว ที่คอยทำงานซ้ำตาม 4 จังหวะนี้ไปเรื่อยๆ

เริ่มจากส่งประวัติบทสนทนาทั้งหมดไปให้โมเดล จากนั้นโมเดลจะตอบกลับมาได้ 2 ทาง คือตอบคำตอบสุดท้ายออกมาเลย หรือขอเรียกใช้ tool ก่อน ถ้าโมเดลเลือกขอ tool ระบบก็แค่สั่งรันคำสั่งนั้น แล้วส่งผลลัพธ์ยัดกลับเข้าประวัติบทสนทนาเพื่อส่งให้โมเดลประมวลผลอีกรอบ วนทำแบบนี้ไปเรื่อยๆ จนกว่าโมเดลจะเลิกขอ tool แล้วคืนคำตอบสุดท้ายออกมา ก็ถือว่าเสร็จสิ้น 1 คำถาม

กลไกหลักแบบนี้เรียกกันว่า agent loop หรือวงจร reason → act → observe นั่นคือคิด ลงมือทำ สังเกตผล แล้ววนกลับมาคิดใหม่ ความสามารถในการทำงานต่อเนื่องยาวๆ ของ Agent ระบบใหญ่ๆ ก็ล้วนต่อยอดมาจากลูปรูปแบบนี้ทั้งสิ้น สิ่งที่โค้ด 9 บรรทัดนี้ทำ จึงเป็นการถอดโครงสร้างลูปออกมาให้เห็นกันชัดๆ แบบเปลือยเปล่า

แกะโค้ด 9 บรรทัดทีละส่วน

นี่คือโค้ดจริงทั้งหมดโดยไม่มีการตัดทอน

import json,sys;from subprocess import getoutput as sh;from urllib.request import Request as R,urlopen
url=sys.argv[1];h=[];b=dict(model="gpt-5.6",input=h,tools=[dict(type="custom",name="sh")])
while p:=input("> "):
  h+=[dict(role="user",content=p)];H={"Content-Type":"application/json"}
  while True:
    o=(r:=json.load(urlopen(R(url,json.dumps(b).encode(),H))))["output"]
    h+=o;c=[i for i in o if i["type"]=="custom_tool_call"];z=r["usage"]["total_tokens"]/10500
    if not c:print(o[-1]["content"][0]["text"],f'\n[{z:06.3f}%]');break
    h+=[dict(type="custom_tool_call_output",call_id=i["call_id"],output=sh(i["input"])) for i in c]

ส่วนตั้งค่าเริ่มต้นจะอ่าน URL ของบริการโมเดลจากพารามิเตอร์ขณะสั่งรันสคริปต์ พร้อมเตรียมลิสต์ว่าง h ไว้เก็บประวัติบทสนทนา จากนั้นจะประกอบก้อนข้อมูลคำขอที่ระบุชื่อโมเดลเป็น gpt-5.6 และประกาศ tool ไว้ 1 ตัวชื่อ sh การรับ URL ตอนรันทำให้โค้ดชุดนี้ต่อกับบริการโมเดลเจ้าไหนก็ได้โดยไม่ยึดติดกับค่ายใดค่ายหนึ่ง

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

ส่วนหัวใจสำคัญจะอยู่ที่ลูปวงในสุด ทำหน้าที่เป็น Agent Loop ตัวจริง โดยจะส่งประวัติบทสนทนาทั้งหมดไปให้โมเดล แล้วแกะผลลัพธ์จาก output มาเช็กดูว่ามีรายการประเภท custom_tool_call หรือไม่ ซึ่งหมายถึงการส่งสัญญาณขอใช้ tool ถ้าไม่มี โค้ดจะแสดงคำตอบสุดท้ายออกทางหน้าจอแล้วออกจากลูปวงใน กลับไปรอรับคำถามใหม่ แต่ถ้ามี โค้ดจะนำคำสั่งที่โมเดลขอไปสั่งรันเป็นคำสั่ง Shell จริงในเครื่องผ่าน sh แล้วนำผลลัพธ์ต่อกลับเข้าลิสต์ประวัติ ก่อนจะวนกลับไปส่งให้โมเดลใหม่อีกครั้ง ทั้งหมดนี้คือกลไกลูปที่ทำงานต่อเนื่องจนกว่าจะเสร็จสิ้น

จุดที่ต้องระวังก่อนนำไปรันจริง

ความสั้นกระชับของโค้ด ย่อมแลกมาด้วยข้อควรระวังสำคัญ เนื่องจาก tool เพียงตัวเดียวที่ประกาศไว้คือ sh ซึ่งเป็นการเรียกใช้ Shell โดยตรง หมายความว่าถ้าโมเดลร้องขอคำสั่งใดๆ เข้ามา ระบบจะสั่งรันคำสั่งนั้นในเครื่องทันที โดยไม่มีการกรองเนื้อหา ไม่มีระบบ Sandbox ป้องกันความเสียหาย และไม่มีขั้นตอนการถามยืนยันใดๆ ในโค้ดชุดนี้

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

ต่อยอดระบบเอง แล้วค่อยเลือกเฟรมเวิร์กอย่างเข้าใจ

พอเห็นแล้วว่า tool เป็นแค่ชื่อที่ประกาศไว้ คู่กับชุดโค้ดที่รอรันตามคำสั่งโมเดล การเพิ่ม tool ใหม่ๆ ก็ใช้รูปแบบเดียวกันเลย นั่นคือตั้งชื่อเครื่องมือใหม่ เขียนคำสั่งรองรับเมื่อโมเดลร้องขอ แล้วส่งผลลัพธ์กลับเข้าประวัติสนทนาตามเดิม จากเดิมที่ค้นหาได้แค่ไฟล์ ก็ขยับไปเรียกใช้ API ดึงข้อมูล หรือทำระบบเฉพาะทางอื่นๆ ได้ตามต้องการ

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

แกนหลักที่ไม่เคยลึกลับ

โค้ด 9 บรรทัดนี้ไม่ได้มีความฉลาดในตัวเอง เพราะความฉลาดทั้งหมดขึ้นอยู่กับตัวโมเดล สิ่งที่โค้ดชุดนี้ทำมีเพียงการเปิดทางให้โมเดลลงมือทำสิ่งต่างๆ ในโลกจริง พร้อมคอยวนลูปให้มันทำงานต่อไปเรื่อยๆ จนกว่าจะได้ผลลัพธ์ที่พอใจ และนั่นคือหัวใจทั้งหมดของคำว่า Agent มาโดยตลอด พอมองทะลุมาถึงลูปสั้นๆ ตรงนี้ คำว่า Agent ก็ไม่ได้ดูซับซ้อนหรือน่ากลัวอีกต่อไป เหลือแค่กลไกพื้นฐานที่เรานำไปประกอบและพัฒนาต่อได้ด้วยตัวเอง

ที่มา: โปรเจกต์ agent in 9 lines python บน GitHub