เรียนรู้ AI agents ตั้งแต่เริ่มต้นใน 6 ขั้นตอน

เส้นทาง 6 ขั้นตอน

หากต้องการเรียนรู้ AI agents ตั้งแต่พื้นฐาน ให้ดำเนินการตาม 6 ขั้นตอนตามลำดับ ได้แก่ แนวคิด, loop แรกของคุณ, tools, memory, การออกแบบ loop และความปลอดภัย แต่ละขั้นตอนมีสิ่งหนึ่งที่คุณต้องสร้างด้วยตนเอง การข้ามไปล่วงหน้าเป็นสาเหตุที่พบบ่อยที่สุดที่ทำให้ผู้เรียนหยุดชะงัก เพราะ framework จะซ่อนส่วนที่คุณจำเป็นต้องเห็นไว้อย่างพอดี

AI agent คือ loop ที่ทำงานครอบ language model ซึ่งได้รับอนุญาตให้เรียกใช้ tools ประโยคนี้คือเนื้อหาทั้งหมดของหัวข้อนี้ ส่วนที่เหลือเป็นรายละเอียดเกี่ยวกับสิ่งที่ใส่ไว้ใน loop, สิ่งที่ tools อาจเข้าถึงได้ และวิธีหยุด loop เมื่อเกิดข้อผิดพลาด หากคุณสามารถอธิบาย loop นี้ให้ผู้อื่นเข้าใจได้ แสดงว่าคุณเรียนรู้เนื้อหานี้แล้ว หากคุณทำได้เพียงระบุชื่อ framework แสดงว่ายังเรียนรู้ไม่สำเร็จ

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

สิ่งที่คุณต้องมีก่อนเริ่มขั้นตอนที่ 1

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

• คุณสามารถอ่านและเขียน Python หรือ TypeScript ได้ในระดับสคริปต์ความยาว 50 บรรทัด
• คุณใช้งาน Linux shell ได้อย่างคล่องตัว: ติดตั้งแพ็กเกจ แก้ไขไฟล์ และอ่าน log
• คุณมี API key สำหรับโมเดลที่ให้บริการผ่านโฮสต์ หรือมีเครื่องที่สามารถเรียกใช้โมเดลภายในเครื่องได้

มีเพียงเท่านี้ คุณไม่จำเป็นต้องมีความรู้ด้านทฤษฎี machine learning และไม่จำเป็นต้องเคยฝึกโมเดลมาก่อน งานด้าน agent ไม่มีส่วนใดเกี่ยวข้องกับ gradient หรือ training data การ์ดกราฟิกมีความสำคัญเฉพาะเมื่อคุณตัดสินใจเรียกใช้โมเดลด้วยตนเอง ซึ่งเป็นทักษะแยกต่างหากที่คุณสามารถเรียนรู้ภายหลังได้จาก การโฮสต์ Ollama บน VPS เพื่อโฮสต์ LLM ด้วยตนเอง

สิ่งที่ผู้คนมักประเมินต่ำเกินไปคือส่วนที่เกี่ยวกับ shell Agent มักทำงานล้มเหลวเนื่องจากสิทธิ์การเข้าถึง path environment variable และ process ที่หยุดทำงานโดยไม่แสดงข้อผิดพลาด หาก stack trace เกี่ยวกับ PATH หรือ file mode ทำให้คุณปิด terminal ให้ใช้เวลาช่วงสุดสัปดาห์ทบทวนพื้นฐาน Linux ก่อน สิ่งนี้จะช่วยประหยัดเวลาให้คุณได้ 1 เดือนในภายหลัง

ขั้นที่ 1: agent คืออะไร และไม่ใช่อะไร

เริ่มด้วย API call 1 ครั้งและไม่ต้องใช้ลูป ส่งพรอมต์ พิมพ์คำตอบ และดูจำนวน token ในการตอบกลับ จากนั้นคุณจะเข้าใจหน่วยของต้นทุนและหน่วยของเวลาแฝง

จากนั้นเรียนรู้การใช้เครื่องมือ ซึ่งเป็นแนวคิดใหม่อย่างแท้จริงเพียงแนวคิดเดียวในสาขานี้ คุณอธิบายฟังก์ชันให้โมเดลทราบในรูปแบบชื่อ คำอธิบาย และ schema ของ JSON (JavaScript object notation) สำหรับอินพุต โมเดลจะไม่เรียกใช้สิ่งใดเอง แต่จะตอบกลับเป็นคำขอแบบมีโครงสร้างว่าให้เรียกใช้ run_command ด้วยอาร์กิวเมนต์เหล่านี้ โค้ดของคุณจะเรียกใช้ฟังก์ชัน ส่งเอาต์พุตกลับไปเป็นข้อความ และส่งคำถามให้โมเดลอีกครั้ง โมเดลทำหน้าที่วางแผนโดยอ่านและเขียนข้อความ ส่วนโค้ดของคุณเป็นส่วนที่ดำเนินการจริง

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

ขั้นที่ 2: เขียนลูปด้วยตนเองสักครั้ง

อย่าเริ่มต้นด้วยเฟรมเวิร์ก เขียน Python ประมาณ 30 บรรทัด เพื่อให้คุณเข้าใจโครงสร้างของโปรแกรมด้วยตนเอง

sudo apt update && sudo apt install -y python3-venv
python3 -m venv ~/agent
source ~/agent/bin/activate
pip install anthropic
export ANTHROPIC_API_KEY=your-key-here

import subprocess
import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "run_command",
    "description": "Run a read only shell command and return its output.",
    "input_schema": {
        "type": "object",
        "properties": {"command": {"type": "string"}},
        "required": ["command"],
    },
}]

messages = [{"role": "user", "content": "How much disk space is free here?"}]

while True:
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        tools=tools,
        messages=messages,
    )
    if response.stop_reason != "tool_use":
        break
    messages.append({"role": "assistant", "content": response.content})
    results = []
    for block in response.content:
        if block.type == "tool_use":
            done = subprocess.run(
                block.input["command"], shell=True,
                capture_output=True, text=True, timeout=10,
            )
            results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": done.stdout or done.stderr,
            })
    messages.append({"role": "user", "content": results})

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

เรียกใช้ด้วย python3 agent.py การทำงานที่ปกติจะแสดงย่อหน้าหนึ่งย่อหน้า ซึ่งระบุชื่อระบบไฟล์และพื้นที่ว่างของระบบไฟล์เหล่านั้น เนื่องจากโมเดลร้องขอ df -h โค้ดของคุณจึงเรียกใช้คำสั่งดังกล่าว และการประมวลผลรอบที่สองแปลงตารางนั้นเป็นประโยค หากไม่มีผลลัพธ์ใดแสดง แสดงว่าลูปสิ้นสุดก่อนที่จะได้รับบล็อกข้อความ เพิ่ม print(response.stop_reason) ไว้ภายในลูป แล้วตรวจสอบค่าที่เปลี่ยนแปลง

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

มีคำเตือนหนึ่งข้อเกี่ยวกับตัวอย่างนี้ ตัวอย่างส่งเอาต์พุตจากโมเดลเข้าสู่ shell โดยตรงด้วย shell=True ซึ่งยอมรับได้บนเครื่องสำหรับทดลองที่คุณสามารถติดตั้งใหม่ได้ แต่ไม่ควรทำในสภาพแวดล้อมอื่น Stage 6 จะแก้ไขประเด็นนี้ แนวคิดเบื้องหลังลูปนี้มีคำอธิบายเพิ่มเติมใน การสร้าง AI agent ของคุณเองบน VPS

ขั้นตอนที่ 3: เครื่องมือที่เอเจนต์ยังไม่มี

เครื่องมือ run_command ของคุณทำงานได้ แต่เอเจนต์ที่ใช้งานจริงต้องใช้เครื่องมือที่เชื่อมต่อกับระบบภายนอก เช่น ระบบตั๋ว ฐานข้อมูล และที่เก็บโค้ด การเขียน wrapper เฉพาะสำหรับแต่ละบริการและแต่ละเอเจนต์ไม่สามารถขยายระบบได้

Model Context Protocol (MCP) คือแนวทางที่อุตสาหกรรมเลือกใช้ MCP server เปิดเผยชุดเครื่องมือผ่าน transport มาตรฐาน และเอเจนต์ที่รองรับ MCP สามารถใช้งานได้โดยไม่ต้องเขียน glue code เฉพาะ ระบบไฟล์อ้างอิงใช้คำสั่งเดียว:

npx -y @modelcontextprotocol/server-filesystem /home/you/projects

คำสั่งนี้ต้องมี Node ติดตั้งอยู่ และอาร์กิวเมนต์ที่เป็นไดเรกทอรีคือ path เดียวที่ server จะเข้าถึง โมเดลความปลอดภัยนี้แสดงหลักการโดยย่อ: server เป็นผู้กำหนดขอบเขต ไม่ใช่ model เมื่อกำหนด client ให้เชื่อมต่อกับ server เอเจนต์ของคุณจะสามารถอ่านและเขียนไฟล์ได้โดยที่คุณไม่ต้องเขียนความสามารถดังกล่าว การเรียกใช้ MCP server อย่างเหมาะสมภายใต้ service account และการเลือก transport ตามรายละเอียด อธิบายไว้ใน การเรียกใช้ MCP server บน VPS สำหรับเอเจนต์เขียนโค้ด AI

บทเรียนของขั้นตอนนี้คือ การออกแบบเครื่องมือคืองานที่สำคัญจริง คำอธิบายที่คลุมเครือทำให้ model ต้องคาดเดา เครื่องมือที่ส่งคืนข้อมูลจำนวน 40,000 อักขระจะทำให้ context window ใช้งานไม่ได้ เครื่องมือที่ลบสิ่งต่าง ๆ ได้ สุดท้ายจะลบสิ่งต่าง ๆ จริงเสมอ

ขั้นที่ 4: หน่วยความจำ ซึ่งส่วนใหญ่เป็นเพียงไฟล์

ผู้เริ่มต้นมักเลือกใช้ฐานข้อมูลเวกเตอร์ในขั้นตอนนี้ แต่ยังไม่ควรทำ อย่างน้อยก็ในตอนนี้

เอเจนต์ไม่มีหน่วยความจำระหว่างการเรียกใช้แต่ละครั้ง คุณต้องส่งบทสนทนาทั้งหมดซ้ำทุกครั้ง นี่จึงเป็นเหตุผลที่เซสชันยาวมีค่าใช้จ่ายต่อรอบสูงกว่าเซสชันสั้น ดังนั้นหน่วยความจำจึงแบ่งเป็น 2 ปัญหา ปัญหาแรกคือสิ่งที่ต้องอยู่ในหน้าต่างบริบทในขณะนั้น ซึ่งคุณจัดการได้ด้วยการสรุป การตัดผลลัพธ์จากเครื่องมือเก่า และการแคชคำนำหน้าพรอมต์ที่คงที่ เพื่อให้จ่ายเพียงเศษส่วนของค่าใช้จ่ายสำหรับส่วนนั้น ปัญหาที่สองคือสิ่งที่คงอยู่หลังการเริ่มระบบใหม่ ซึ่งก็คือการจัดเก็บข้อมูล

สำหรับปัญหาที่สอง ไฟล์ markdown ธรรมดาที่เอเจนต์สามารถอ่านและเขียนได้ เหมาะกว่าฐานข้อมูลเวกเตอร์สำหรับโครงการแรกเกือบทุกโครงการ ให้เอเจนต์ใช้ไฟล์หนึ่งไฟล์ ระบุรูปแบบให้ชัดเจน และกำชับให้อ่านไฟล์นั้นก่อนเริ่มทำงาน รวมทั้งอัปเดตไฟล์เมื่อเรียนรู้ข้อมูลใหม่ คุณจะได้รับประโยชน์เกือบทั้งหมด และสามารถเปิดไฟล์เพื่อดูสิ่งที่เอเจนต์เชื่อได้ เมื่อบันทึกเริ่มมีขนาดใหญ่เกินกว่าจะอยู่ในหน้าต่างบริบทได้ จึงค่อยใช้ embeddings และ retrieval ไม่ควรใช้ก่อนหน้านั้น

ระยะที่ 5: ลูปคือผลิตภัณฑ์

ถึงขั้นนี้ คุณสามารถสร้างเอเจนต์ที่ทำงานได้ขณะที่คุณเฝ้าดูอยู่ ระยะที่ 5 คือการทำให้เอเจนต์ทำงานได้แม้ไม่มีคุณคอยดูแล

มีคำถาม 4 ข้อที่ใช้ตัดสินว่าเอเจนต์แบบไม่ต้องมีผู้ดูแลจะปล่อยให้ทำงานเองได้อย่างปลอดภัยหรือไม่ อะไรเป็นตัวเรียกใช้งาน เพื่อให้เอเจนต์ไม่ทำงานโดยไม่มีเหตุผล ขอบเขตการทำงานคืออะไร เพื่อให้ความผิดพลาดส่งผลกระทบเพียงเล็กน้อย จะตรวจสอบผลลัพธ์อย่างไร เพราะเอเจนต์ที่ตรวจการบ้านของตัวเองจะให้คะแนนผ่านเสมอ งบประมาณใดจะหยุดเอเจนต์ ไม่ว่าจะกำหนดเป็น tokens หรือเวลานาฬิกาจริง การออกแบบองค์ประกอบทั้ง 4 ข้อนี้อย่างตั้งใจคือหลักปฏิบัติที่อธิบายไว้ใน วิศวกรรมลูปและขอบเขตของคำจำกัดความนี้

แบบฝึกหัด: นำเอเจนต์ระยะที่ 2 ของคุณมา กำหนดงานที่ต้องใช้ 4 หรือ 5 ขั้นตอน แล้วเพิ่มขีดจำกัดจำนวนรอบการทำงานที่แน่นอน จากนั้นนำขีดจำกัดออกและดูว่าลูปที่ไม่จำกัดส่งผลต่อค่าใช้จ่าย tokens ของคุณอย่างไร ให้ทดลองนี้เพียงครั้งเดียวโดยใช้งบประมาณขนาดเล็ก เพื่อไม่ให้คุณทำโดยไม่ตั้งใจเมื่อใช้งบประมาณขนาดใหญ่

ขั้นที่ 6: ความปลอดภัย ข้อมูลลับ และค่าใช้จ่าย

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

เรียกใช้ agent ด้วยผู้ใช้ที่ไม่มีสิทธิ์พิเศษของตนเอง ห้ามใช้ root และห้ามใช้บัญชีของคุณเอง เพื่อจำกัดขอบเขตความเสียหายให้อยู่ในไดเรกทอรีแทนที่จะกระทบทั้งเครื่อง เก็บข้อมูลรับรองให้พ้นจากการเข้าถึงของโมเดล เพราะทุกสิ่งที่อยู่ใน context window อาจถูกส่งกลับออกมาผ่าน tool call ได้ วิธีแก้คือใช้โทเค็นอายุสั้นที่กำหนดขอบเขตและเรียกใช้ผ่าน helper ตามที่อธิบายไว้ใน การเก็บข้อมูลลับให้พ้นจาก AI agents กำหนดเพดานค่าใช้จ่ายที่แน่นอน เพราะลูปที่ทำงานโดยไม่มีผู้ควบคุมจะคิดค่าใช้จ่ายในทุกรอบโดยไม่มีใครเฝ้าดู และการกำหนดขีดจำกัดกับการประมวลผลแบบกลุ่มที่ช่วยควบคุมค่าใช้จ่ายมีอธิบายไว้ใน การควบคุมค่าใช้จ่ายของ AI agent บน VPS ที่ทำงานตลอดเวลา

ควรระบุค่าใช้จ่ายเป็นตัวเลขที่ชัดเจนหนึ่งรายการ ณ เดือน July 2026 Claude Opus 5 คิดค่าบริการ $5 ต่อ input tokens หนึ่งล้านรายการ และ $25 ต่อ output tokens หนึ่งล้านรายการ อีกทั้ง agent ที่ส่งบทสนทนาที่ขยายตัวขึ้นซ้ำไปมาอาจส่งข้อมูลหลายแสนโทเค็นผ่านงานเดียวได้ การแคช prompt และการใช้โมเดลขนาดเล็กกว่าสำหรับขั้นตอนประจำ จะเปลี่ยนการคำนวณนี้ได้มากกว่าการปรับ prompt เพียงเล็กน้อย

ควรกล่าวถึง prompt injection ในขั้นตอนนี้ด้วย หาก agent อ่านหน้าเว็บ issue tracker หรือ inbox ผู้เขียนข้อความนั้นก็กำลังเขียนคำสั่งให้ agent ของคุณเช่นกัน การป้องกันไม่ใช่การเขียน system prompt ให้ฉลาดขึ้น แต่คือการกำหนดขอบเขต เพราะ agent ที่ไม่สามารถลบ repository ได้ ย่อมไม่สามารถถูกชักจูงให้ลบ repository ได้

ควรเลือกแผนการเรียนใด?

เลือกหลักสูตรเดียวและเรียนให้จบ แทนการทดลองเรียนทั้ง 6 หลักสูตรแบบไม่ต่อเนื่อง ที่เก็บ ai-agents-for-beginners ของ Microsoft เป็นหลักสูตรฟรีที่สมบูรณ์ที่สุด มีบทเรียน 18 บท และมียอดดาวมากกว่า 70,000 ดวง ณ เดือนกรกฎาคม 2026 อีกทั้งยังสอดคล้องกับแต่ละระยะข้างต้นอย่างชัดเจน บทความรวบรวมที่จัดอันดับที่เก็บ agent ที่กำลังได้รับความนิยมมีประโยชน์สำหรับดูว่ามีโครงการใดบ้าง แต่เหมาะเป็นหลักสูตรน้อยกว่ามาก เพราะรายการที่เรียงตามจำนวนดาวจะเรียงตามความนิยม ไม่ใช่ตามลำดับการเรียนรู้

เมื่อคุณต้องการโครงการจริงสำหรับฝึกปฏิบัติ coding agent เป็นเป้าหมายแรกที่เหมาะสมที่สุด เพราะได้รับผลลัพธ์ทันที เครื่องมือมีความชัดเจน และข้อผิดพลาดย้อนกลับได้ง่าย การเรียกใช้ coding AI agent บน VPS อธิบายขั้นตอนตั้งแต่ต้นจนจบ หากคุณต้องการศึกษาระบบที่ทำงานอยู่แทนการสร้างตั้งแต่เริ่มต้น การเปรียบเทียบใน AI agent แบบ self-hosted ที่ดีที่สุด แสดงให้เห็นว่าโครงการหลายโครงการแก้ปัญหาลูปเดียวกันด้วยแนวทางที่แตกต่างกันอย่างไร

ใช้เวลานานเท่าใด

สำหรับผู้ที่เขียนโปรแกรมเป็นอยู่แล้ว ขั้นที่ 1 และ 2 ใช้เวลาประมาณหนึ่งเย็น ขั้นที่ 3 ใช้เวลาหนึ่งสุดสัปดาห์ โดยส่วนใหญ่ใช้ไปกับคำอธิบายเครื่องมือ ไม่ใช่การทำความเข้าใจโพรโทคอล ขั้นที่ 4 และ 5 ต้องใช้งานจริงเป็นเวลาหลายสัปดาห์ เพราะคุณจะเรียนรู้ได้ว่าเอเจนต์ของคุณลืมอะไร ก็ต่อเมื่อเฝ้าสังเกตการลืมของมัน ขั้นที่ 6 ไม่เคยเสร็จสมบูรณ์อย่างแท้จริง เพราะทุกความสามารถใหม่ที่คุณมอบให้จะทำให้ต้องกลับมาทบทวนขั้นนี้อีกครั้ง

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

FAQ

จำเป็นต้องมีความรู้ด้าน machine learning เพื่อสร้าง AI agent หรือไม่

ไม่จำเป็น การสร้าง agent คือการเรียกใช้ model ผ่าน API และเชื่อมคำขอใช้เครื่องมือเข้ากับฟังก์ชันจริง ซึ่งเป็นการเขียนโปรแกรมแอปพลิเคชันทั่วไป คุณไม่ต้องจัดการกับการฝึก model, gradients หรือ datasets ทักษะที่กำหนดว่า agent จะทำงานได้หรือไม่ ได้แก่ การออกแบบ schema สำหรับเครื่องมือ การจัดการข้อผิดพลาด และสิทธิ์ของ Linux ทฤษฎี machine learning จะเกี่ยวข้องก็ต่อเมื่อคุณต้องการ fine tune model ต่อ ซึ่งเป็นงานคนละประเภทและมีข้อกำหนดเบื้องต้นต่างกัน

ควรเริ่มด้วย framework เช่น LangChain หรือ CrewAI หรือไม่

ให้เขียนลูปแบบ raw เพียง 1 ลูปก่อน แล้วจึงเลือกใช้ framework framework จะแทนที่โค้ด 30 บรรทัดใน stage 2 ด้วยออบเจ็กต์การกำหนดค่า ซึ่งสะดวกเมื่อคุณเข้าใจแล้วว่า framework แทนที่อะไร แต่จะทำให้สับสนหากยังไม่เคยเห็นกลไกดังกล่าว เมื่อ agent ทำงานผิดปกติ คุณต้องวิเคราะห์รายการข้อความและผลลัพธ์จากเครื่องมือโดยตรง ซึ่งทำได้ยากกว่ามากหากคุณไม่เคยเห็นข้อมูลเหล่านี้ หลังจากเขียนลูปด้วยตนเองแล้ว 1 ลูป framework จะช่วยประหยัดเวลาแทนที่จะซ่อนกลไกการทำงาน

การเรียนรู้ AI agent มีค่าใช้จ่ายเท่าใด

น้อยกว่าที่คนส่วนใหญ่คาดไว้ หากคุณกำหนดเพดานค่าใช้จ่าย API key แบบ hosted และ VPS ขนาดเล็กเพียงพอสำหรับทั้ง 6 stage นี้ ความเสี่ยงที่แท้จริงไม่ใช่อัตราค่าบริการรายชั่วโมง แต่คือการที่ลูปทำงานต่อไปโดยไม่มีขอบเขตและเรียกเก็บค่าบริการทุก iteration ขณะที่คุณหลับ ตั้งขีดจำกัดค่าใช้จ่ายสูงสุดในบัญชี API ตั้งแต่วันแรก เพิ่มขีดจำกัดจำนวน iteration ให้กับทุกลูปที่เขียน และใช้ model ที่มีราคาถูกกว่าสำหรับขั้นตอนทั่วไป การเรียกใช้ model ภายในเครื่องจะตัดค่าใช้จ่าย token ออก แต่จะเพิ่มข้อกำหนดด้านฮาร์ดแวร์เข้ามาแทน

AI agent แตกต่างจาก chatbot อย่างไร

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