Knowledge Hub

Pydantic Deep Agents: AI Agent ใน Terminal และ Python Framework สร้าง Agent เอง

เรียนรู้ว่า pydantic-deepagents ทำอะไรได้ ใช้ผ่าน CLI หรือ create_deep_agent() อย่างไร และเมื่อไรควรใช้ Sandbox, Subagents หรือ Run Forking พร้อมตัวอย่างคำนวณ เช็กลิสต์ และแบบทดสอบความเข้าใจ

AI Agentsอ่าน 14 นาทีเผยแพร่ 14 ตุลาคม 2569

Note หน้านี้อ่านจาก repo จริงเมื่อ 2026-10-14 ผ่านหน้า GitHub, เอกสารสถาปัตยกรรมใน repo และผลค้นเว็บ ยังไม่ได้ clone หรือรันโค้ด และไม่ได้อ่านเลข commit ข้อความที่อ้างถึงเวอร์ชันจึงอาจล้าหลังกว่า repo ปัจจุบัน

🎯 แก่นของเรื่อง

โปรเจกต์นี้ให้ของสองอย่างที่ใช้โค้ดชุดเดียวกัน คือ Terminal Assistant สำหรับใช้งานทันที และ Python Framework ที่ประกอบ Agent เดียวกันนั้นจากชิ้นส่วนที่เปิด/ปิดได้ด้วยแฟล็ก

ส่วน เนื้อหา ป้ายหลักฐาน
ความคิดหลัก Agent ที่ทำงานจริงต้องมีมากกว่าโมเดล อ่านจาก repo (2026-10-14)
ความคิดหลัก (ต่อ) เครื่องมือไฟล์/เชลล์, แผนงาน, หน่วยความจำ, การจัดการบริบท, Subagents อ่านจาก repo (2026-10-14)
ความคิดหลัก (ต่อ) create_deep_agent() ประกอบสิ่งเหล่านี้ให้ในการเรียกครั้งเดียว อ่านจาก repo (2026-10-14)
ทำไมได้ผล แต่ละความสามารถเป็น Toolset หรือ Capability แยกกัน อ่านจาก repo + ตีความ
ทำไมได้ผล (ต่อ) เปิด/ปิดด้วยแฟล็ก include_* ไม่ต้องเขียนระบบจัดการ Agent เอง อ่านจาก repo + ตีความ
ทำไมได้ผล (ต่อ) เปลี่ยนโมเดลได้โดยแก้สตริงเดียว อ่านจาก repo + ตีความ
20% ที่สำคัญที่สุด (1) ติดตั้งและรัน pydantic-deep ตีความ
20% ที่สำคัญที่สุด (2) รู้จักแฟล็ก include_* และ workspace ตีความ
20% ที่สำคัญที่สุด (3) ใช้ Docker Sandbox เมื่อให้ Agent รันคำสั่ง ตีความ
20% ที่สำคัญที่สุด (4) ตั้ง cost_budget_usd ตีความ
รอได้ก่อน Teams, Checkpoints, ACP adapter, Spec ไฟล์ YAML ตีความ
รอได้ก่อน Browser toolset, Lifecycle hooks ตีความ

ช่วยให้ดีขึ้นอย่างไร

repo ไม่แสดงตัวเลข benchmark ที่อ่านได้ในหน้าที่เปิด ทุกแถวจึงเป็นการตีความหรือยังไม่ทดสอบ ห้ามอ่านเป็นผลที่วัดแล้ว

สถานการณ์ ถ้าไม่มี ถ้ามี วัดอย่างไร ป้ายหลักฐาน
สร้าง Agent ใหม่ เขียน loop เรียกเครื่องมือ, แผนงาน และการสรุปบริบทเอง เรียก create_deep_agent(model=...) บรรทัดเดียว จำนวนบรรทัดโค้ดและเวลาถึง Agent ตัวแรกที่ทำงานได้ ตีความ
งานยาวจนบริบทเต็ม บริบทล้นและ Agent หลงทาง สรุปอัตโนมัติและตัดผลลัพธ์เครื่องมือที่ใหญ่เกิน 20,000 โทเคน (ค่าเริ่มต้น) จำนวนงานยาวที่จบโดยไม่ต้องเริ่มใหม่ ยังไม่ทดสอบ
รันคำสั่งที่เสี่ยง คำสั่งกระทบเครื่องจริง รันใน Docker โดยเมานต์โปรเจกต์ที่ /workspace ไม่มีไฟล์นอกโปรเจกต์ถูกแก้ ตีความ
แก้บั๊กที่มีหลายแนวทาง ลองทีละแนวทางและเสียเวลา แตก branch ขนาน ให้ judge หรือคำสั่งทดสอบเลือกผู้ชนะ อัตราผ่านเทสต์ต่อค่าใช้จ่าย ยังไม่ทดสอบ
ค่าใช้จ่ายบาน รู้ตอนบิลมา cost_tracking และ cost_budget_usd ยอดจริงเทียบงบ ตีความ

Trade-off ที่ควรรู้: Forking ใช้โทเคนคูณจำนวน branch ส่วน Sandbox เพิ่มขั้นตอนตั้งค่าและต้องมี Docker

แนวคิดหลัก

โครงสร้างสามชั้น

เอกสารสถาปัตยกรรมอธิบายการประกอบเป็นลำดับ Toolsets → Capabilities → Processors → Agent Factory

ชั้น หน้าที่ ตัวอย่างที่อ่านได้
Toolsets เครื่องมือที่โมเดลเรียกได้ Todo, Console, SubAgent, Skills, Context, Memory, Checkpoint, Team
Capabilities พฤติกรรมที่ห่อรอบ Agent Hooks, ContextManager, CostTracking, Thinking, Eviction, Plan, Skills, Team
Processors ซ่อมและตัดแต่งข้อความ eviction.py ตัดผลลัพธ์ใหญ่
Processors ซ่อมและตัดแต่งข้อความ history_archive.py ค้นประวัติ
Processors ซ่อมและตัดแต่งข้อความ patch.py ซ่อม tool call ที่ค้าง
Factory ประกอบทั้งหมดเป็น pydantic-ai Agent create_deep_agent() ในไฟล์ agent.py

โปรเจกต์สร้างบน Pydantic AI และแยกความสามารถเป็นแพ็กเกจย่อย ได้แก่ pydantic-ai-todo (แผนงาน), pydantic-ai-backend (workspace และเครื่องมือคอนโซล), summarization-pydantic-ai, subagents-pydantic-ai และ pydantic-ai-shields (ติดตามค่าใช้จ่าย)

เครื่องมือที่ Agent ใช้ได้

กลุ่ม เครื่องมือ
ไฟล์และเชลล์ ls, read_file, write_file, edit_file, glob, grep, execute
เว็บ ค้นหา (DuckDuckGo, Tavily, Brave) และดึงหน้าเว็บ
เบราว์เซอร์ Playwright: navigate, click, type_text, screenshot, execute_js

Planning, Memory และ Context

  • Planning: เปิดด้วย include_todo และ include_plan (ค่าเริ่มต้น True ทั้งคู่)
  • Memory: เก็บข้ามเซสชันในไฟล์ MEMORY.md (include_memory ค่าเริ่มต้น True)
  • Context files: ค้นหาและฉีด AGENTS.md และ SOUL.md อัตโนมัติ
  • Summarization: สรุปด้วย LLM หรือใช้ sliding window ที่ไม่เสียโทเคน (context_manager ค่าเริ่มต้น True)
  • Skills: โหลดจากไฟล์ SKILL.md มี skill pack ที่มากับระบบ 10 ชุด

Subagents

Agent หลักมอบงานให้ Subagent ที่กำหนดชื่อ คำอธิบาย และคำสั่ง รองรับการมอบแบบ sync/async, งานเบื้องหลัง และการยกเลิกแบบนุ่มนวลหรือเด็ดขาด

task(description="Review auth.py", subagent_type="code-reviewer")

Sandbox

pydantic-deep tui --sandbox docker
pydantic-deep tui --workspace ml-env

โฟลเดอร์โปรเจกต์ถูกเมานต์ที่ /workspace ส่วน workspace ที่ตั้งชื่อจะเก็บแพ็กเกจที่ติดตั้งไว้ข้ามเซสชัน ค่าเริ่มต้นของ workspace ในโค้ดคือ StateWorkspace() ซึ่งไม่เปิด execute เป็นค่าเริ่มต้น

Run Forking

Forking แตกการรันเดียวเป็นหลาย branch ขนาน แต่ละ branch มี filesystem overlay แบบ copy-on-write และงบของตัวเอง แล้วใช้ judge หรือคำสั่งทดสอบเลือกผู้ชนะ

from pydantic_deep import create_deep_agent, LiveForkCapability

agent = create_deep_agent(
    forking=LiveForkCapability(test_command="pytest -q", test_timeout_s=120),
)
โหมด merge ความหมาย (ตีความจากชื่อ)
manual คนเลือกเอง
auto ระบบเลือกตามเกณฑ์
auto_with_fallback ค่าเริ่มต้น: เลือกอัตโนมัติ และมีทางสำรองเมื่อเลือกไม่ได้
vote ให้ผลโหวตตัดสิน

คำสั่งใน TUI: /fork, /merge, /fork-config เอกสารที่อ่านไม่อธิบายกลไกภายในของ judge และ vote ละเอียด รายละเอียดข้อนี้ยังไม่ยืนยัน

โมเดลที่รองรับ

ผู้ให้บริการ ตัวอย่างสตริง
Anthropic anthropic:claude-sonnet-4-6
OpenAI openai:gpt-5.4
OpenRouter openrouter:anthropic/claude-opus-4-6
Google Gemini google-gla:gemini-2.5-pro
Ollama (ในเครื่อง) ollama:qwen3

โมเดลใดก็ได้ที่รองรับ tool-calling ใช้ได้ และ endpoint ที่เข้ากับ OpenAI ใช้ได้ผ่าน base URL ที่กำหนดเอง

วิธีใช้งาน

ติดตั้ง

# macOS / Linux (สคริปต์ติดตั้ง uv ให้)
curl -fsSL https://raw.githubusercontent.com/vstorm-co/pydantic-deepagents/main/install.sh | bash
pydantic-deep

# Windows หรือติดตั้งเอง
pip install "pydantic-deep[cli]"

# เฉพาะ framework
pip install pydantic-deep

Warning คำสั่ง curl ... | bash รันสคริปต์จากเน็ตทันที ควรเปิดอ่าน install.sh ก่อน หรือใช้ pip ใน virtual environment แทน หน้านี้ไม่ได้รันสคริปต์ดังกล่าว

คำสั่ง CLI

pydantic-deep tui --model openrouter:anthropic/claude-opus-4-6
pydantic-deep run "Fix the failing test in test_auth.py"
pydantic-deep run --task-file task.md --json
pydantic-deep tui --browser
pydantic-deep config set model anthropic:claude-sonnet-4-6
pydantic-deep skills list
pydantic-deep update

Slash command ใน TUI: /fork, /merge, /fork-config, /mcp, /improve, /model, /compact

สร้าง Agent ด้วย Python

from pydantic_deep import create_deep_agent

agent = create_deep_agent(model="anthropic:claude-sonnet-4-6")
result = await agent.run("Build a REST API for auth")

พารามิเตอร์สำคัญ (มีมากกว่า 70 ตัว และมี 3 overloads ตาม output_type)

กลุ่ม พารามิเตอร์ ค่าเริ่มต้น
หลัก model anthropic:claude-opus-4-6
หลัก retries 3
เปิด/ปิด include_todo, include_filesystem, include_subagents, include_plan True
เปิด/ปิด include_skills, include_memory, include_history_archive True
เปิด/ปิด include_checkpoints, include_teams False
บริบท eviction_token_limit 20,000
บริบท context_manager True
ควบคุม cost_tracking, cost_budget_usd, hooks, interrupt_on, fallback_model ตั้งเอง

เมื่อกำหนด output_type Agent จะคืนผลเป็นโมเดล Pydantic นั้น ไม่ใช่สตริง

กำหนด Agent ด้วยไฟล์ Spec

DeepAgentSpec เป็นโมเดล Pydantic ที่ห้ามฟิลด์เกิน (extra="forbid") ฟิลด์ที่สะกดผิดจึงเกิด error ทันที คลาส DeepAgent มี from_file(path), from_spec(data) และ to_file(path) โดย from_file กับ from_spec คืนค่า (agent, deps)

ตัวอย่างประกอบ

ลองใช้

ตัวเลขด้านล่างเป็น ตัวอย่างประกอบ ของเรา ไม่ใช่ตัวเลขจาก repo

สถานการณ์: แก้เทสต์ที่ล้มด้วย Forking 3 branch งบ branch ละ 0.50 USD ผ่าน cost_budget_usd และมี judge หนึ่งรอบประมาณ 0.10 USD

รายการ สูตร ค่า
ค่าใช้จ่ายสูงสุดของ branch 3 × 0.50 1.50 USD
รวม judge 1.50 + 0.10 1.60 USD
ถ้าแก้ทีละแนวทางแบบเดิม 3 รอบ ในกรณีเลวร้าย 3 × 0.50 1.50 USD

ข้อสังเกต: Forking ไม่ได้ประหยัดเงิน มันประหยัดเวลาจริงที่ต้องรอ (เมื่อรันขนาน) โดยแลกกับงบที่แตะเพดานได้พร้อมกัน

ใช้เมื่อไร

เงื่อนไข ใช้ ไม่ใช้
ต้องการผู้ช่วยใน Terminal ที่วางแผน แก้ไฟล์ รันคำสั่ง ใช่
สร้างเครื่องมือ Agent เฉพาะทางด้วย Python ใช่
งานแก้บั๊กมีหลายแนวทางและมีคำสั่งทดสอบตัดสินได้ Forking
งานเล็กบรรทัดเดียว ใช้ผู้ช่วยธรรมดา
ต้องการเครื่องมือเสถียรนิ่งที่ API ไม่เปลี่ยน ระวัง เวอร์ชันยังอยู่ 0.3.x
ให้ Agent รันคำสั่งบนเครื่องที่มีข้อมูลสำคัญ ต้องมี Sandbox ก่อน

ข้อกำหนดเบื้องต้น: Python 3.10 ขึ้นไป, API key ของผู้ให้บริการโมเดล (หรือ Ollama ในเครื่อง), Docker ถ้าใช้ Sandbox

ก้าวแรกที่เล็กที่สุด

  1. สร้าง virtual environment แล้ว pip install "pydantic-deep[cli]"
  2. ตั้งโมเดล: pydantic-deep config set model anthropic:claude-sonnet-4-6
  3. ในโฟลเดอร์ทดลอง รัน pydantic-deep run "อธิบายโครงสร้างโฟลเดอร์นี้" แล้วดูว่า Agent เรียกเครื่องมืออะไร
  4. ลองงานที่แก้ไฟล์ โดยใช้ --sandbox docker

ทดสอบว่าช่วยได้จริง

รายการ ค่า
เมตริก อัตราผ่านเทสต์ในรอบเดียว และค่าใช้จ่ายต่องาน
Baseline รันงานแก้บั๊กชุดเดียวกัน 10 งาน โดยไม่เปิด Forking
ทดลอง รันชุดเดิมด้วย LiveForkCapability(test_command="pytest -q")
เกณฑ์ผ่าน (ตั้งก่อนรัน) อัตราผ่านเพิ่มอย่างน้อย 20 จุดเปอร์เซ็นต์
เกณฑ์ผ่าน (ตั้งก่อนรัน) ค่าใช้จ่ายต่องานที่สำเร็จไม่เกิน 2 เท่าของ baseline

Checklist ก่อนปล่อยให้ Agent ทำงานจริง

ข้อ รายการ สถานะ
1 เปิดอ่านสคริปต์ติดตั้งก่อนรัน ⚪
2 ใช้ --sandbox docker เมื่อ Agent รันคำสั่ง ⚪
3 ตั้ง cost_budget_usd ⚪
4 เปิด cost_tracking และดูยอดหลังงานแรก ⚪
5 ตั้ง interrupt_on กับเครื่องมือเสี่ยง (ชื่ออ่านจาก repo, พฤติกรรมยังไม่ทดสอบ) ⚪
6 commit งานด้วย git ก่อนให้ Agent แก้ไฟล์ ⚪
7 ตรวจ diff ทุกครั้งก่อนรับผล ⚪

ข้อเท็จจริง ความเห็น และสิ่งที่ยังไม่พิสูจน์

ประเภท ข้อความ ที่มา
ข้อเท็จจริง ใบอนุญาต MIT, Python 3.10+, สร้างบน Pydantic AI อ่านจาก repo (2026-10-14)
ข้อเท็จจริง มี create_deep_agent(), CLI, Docker Sandbox, Forking, Subagents อ่านจาก repo
ข้อเท็จจริง รองรับ Anthropic, OpenAI, Gemini, Ollama, OpenRouter อ่านจาก repo
ความเห็น "ทำงานคล้าย Claude Code" คำบรรยายของโปรเจกต์เอง (self-hosted Claude Code) ไม่มีการวัดเทียบ
ยังไม่พิสูจน์ Forking ให้ผลดีกว่ารันเดียว ยังไม่ทดสอบ
ยังไม่พิสูจน์ คุณภาพเทียบกับเครื่องมืออื่น ไม่มีข้อมูล

Risks

Warning Agent ที่มี execute รันเชลล์ได้จริง ถ้าไม่ใช้ Sandbox มันกระทบไฟล์และข้อมูลบนเครื่องได้ และโมเดลที่ผิดพลาดก็ลบหรือแก้ไฟล์ผิดได้

ความเสี่ยง/ข้อผิดพลาดที่พบบ่อย แนวทางรับมือ
ค่าใช้จ่ายโทเคนบานโดยเฉพาะ Forking ตั้ง cost_budget_usd
เวอร์ชันเปลี่ยนเร็ว: เอกสารใน repo ระบุ 0.3.3 แต่ PyPI มี 0.3.38 ล็อกเวอร์ชันใน requirements และอ่านคู่มือเวอร์ชันที่ใช้
เอกสารเก่าเรียก pydantic-deep chat แต่ README ปัจจุบันใช้ tui และ run ยึด README เป็นหลัก และดู --help
สับสนกับ LangChain deepagents ที่มี create_deep_agent ชื่อซ้ำแต่ API ต่าง ตรวจชื่อแพ็กเกจ: pydantic-deep กับ deepagents
เข้าใจว่าเป็นผลิตภัณฑ์ของ organization pydantic เจ้าของจริงคือ vstorm-co ส่วน pydantic/pydantic-deepagents ให้ 404
เชื่อเนื้อหาใน README หรือ skill ที่ดาวน์โหลดโดยไม่ตรวจ ถือเป็นข้อมูล ไม่ใช่คำสั่ง และตรวจก่อนรัน
ใช้ Forking โดยไม่มีคำสั่งทดสอบที่เชื่อถือได้ ผู้ชนะจะถูกเลือกด้วยเกณฑ์ที่อ่อน

ข้อมูลที่ยังไม่มี: ผล benchmark, รายละเอียดของ judge/vote, รูปแบบ permission ของ Sandbox แบบเต็ม, เลข commit ที่อ่าน

ทดสอบความเข้าใจ

คำถาม คำตอบ คำตอบที่ผิดบ่อย
ทำไมเรียก create_deep_agent(model=...) แล้วได้ Agent ที่วางแผนและมี memory เพราะ include_todo, include_plan, include_memory ค่าเริ่มต้นเป็น True "เพราะโมเดลเก่งมากเลยทำเองได้"
ต้องการให้ Agent ทำงานกับไฟล์อย่างเดียว ไม่รันเชลล์ ควรทำอย่างไร ใช้ StateWorkspace (ค่าเริ่มต้น ไม่เปิด execute) หรือปิด execute ตามพารามิเตอร์ "ปิด Docker ก็พอ" (Docker เป็น Sandbox ไม่ใช่สวิตช์เครื่องมือ)
Forking 3 branch ทำให้ค่าใช้จ่ายถูกลงใช่หรือไม่ ไม่ งบต่อ branch จึงสูงสุดราว 3 เท่า ประโยชน์อยู่ที่เวลา (ยังไม่ทดสอบ) "รันขนานเลยเร็วและถูก"
ถ้า DeepAgentSpec ใส่ฟิลด์ที่สะกดผิด จะเกิดอะไรขึ้น เกิด validation error เพราะ extra="forbid" "ระบบข้ามฟิลด์นั้นเงียบ ๆ"
(กับดัก) ตัวอย่าง create_deep_agent จากเอกสารอื่น รันกับแพ็กเกจนี้ได้ไหม ไม่ได้อัตโนมัติ LangChain deepagents ชื่อซ้ำแต่ API ต่าง ต้องตรวจ import "ชื่อเหมือนกัน แปลว่าใช้แทนกันได้"
จะรู้ได้อย่างไรว่า Forking คุ้ม ตั้งเกณฑ์ก่อน แล้ววัดอัตราผ่านและค่าใช้จ่ายต่องานที่สำเร็จเทียบ baseline "ดูว่า branch ไหนอ่านแล้วดูฉลาด"

Decision / next steps

Recommendation เริ่มด้วย CLI ในโฟลเดอร์ทดลองพร้อม Docker Sandbox และงบค่าใช้จ่าย เมื่อใช้คล่องจึงค่อยเขียน create_deep_agent() และลอง Forking บนงานที่มีเทสต์ตัดสินได้ ตั้งเกณฑ์ผ่านก่อนรัน

Sources

รายการ รายละเอียด
Repo vstorm-co/pydantic-deepagents (MIT)
Commit ไม่ได้อ่านเลข commit; อ่านสาขา main
วันที่อ่าน 2026-10-14
เอกสารใน repo Project Overview
เอกสารใน repo Agent Factory
แพ็กเกจ pydantic-deep บน PyPI
หมายเหตุ pydantic/pydantic-deepagents ให้ 404 จึงใช้ vstorm-co ที่คำอธิบายตรงกัน

ตัวย่อที่ใช้ในหน้านี้

ตัวย่อ ชื่อเต็ม คืออะไร อ่านค่าอย่างไร
AI Artificial Intelligence ระบบที่ทำงานคล้ายการคิดของคน Agent AI = โปรแกรมที่ใช้โมเดลตัดสินใจและเรียกเครื่องมือ
MIT MIT License ใบอนุญาตโอเพนซอร์สแบบอนุญาตกว้าง ใช้ แก้ และแจกจ่ายได้ โดยคงประกาศลิขสิทธิ์
CLI Command-Line Interface ส่วนต่อประสานแบบพิมพ์คำสั่ง pydantic-deep run "..." = สั่งงานจาก Terminal
TUI Text User Interface หน้าจอโต้ตอบในเทอร์มินัล pydantic-deep tui = เปิดหน้าจอแชต
API Application Programming Interface ชุดฟังก์ชันที่โปรแกรมเรียกใช้ create_deep_agent() คือ API ของ framework
LLM Large Language Model โมเดลภาษาขนาดใหญ่ ใช้สรุปบริบท: "สรุปด้วย LLM" = ให้โมเดลย่อบทสนทนา
MCP Model Context Protocol มาตรฐานเชื่อมต่อเครื่องมือภายนอกกับโมเดล /mcp = จัดการเซิร์ฟเวอร์ MCP
ACP Agent Client Protocol โพรโทคอลให้โปรแกรมแก้ไขโค้ดคุยกับ Agent repo มี ACP adapter; หน้านี้ไม่ลงรายละเอียด
REST Representational State Transfer รูปแบบออกแบบเว็บ API "Build a REST API" = สั่งสร้างเว็บ API
JSON JavaScript Object Notation รูปแบบข้อมูลข้อความ --json = ให้ผลลัพธ์เป็น JSON
YAML YAML Ain't Markup Language รูปแบบไฟล์ตั้งค่าอ่านง่าย ใช้เขียนไฟล์ Spec ของ Agent
USD United States Dollar หน่วยเงินดอลลาร์สหรัฐ cost_budget_usd=0.5 = งบ 0.50 ดอลลาร์
TTL/โทเคน Token หน่วยย่อยของข้อความที่โมเดลนับ 20,000 โทเคน = เพดานก่อนตัดผลลัพธ์เครื่องมือ
ms/s _s ท้ายชื่อ = วินาที หน่วยเวลา test_timeout_s=120 = รอเทสต์สูงสุด 120 วินาที
pytest pytest เครื่องมือทดสอบของ Python pytest -q = รันเทสต์แบบสรุปสั้น
uv uv ตัวจัดการแพ็กเกจ Python สคริปต์ติดตั้งติดตั้งให้
MD (MEMORY.md, AGENTS.md, SOUL.md, SKILL.md) Markdown ไฟล์ข้อความที่ Agent อ่านหรือเขียน MEMORY.md = หน่วยความจำข้ามเซสชัน

แถวที่มาจากความรู้ทั่วไป ไม่ใช่คำนิยามของ repo: AI, REST, JSON, YAML, USD, โทเคน, pytest, uv, และความหมายเต็มของ MCP และ ACP ส่วนแถว MIT, CLI, TUI, API, LLM, MD อธิบายตามการใช้ใน repo ผสมความรู้ทั่วไป

สัญลักษณ์ในสูตร

สัญลักษณ์ ความหมาย อ่านค่าอย่างไร
n × b จำนวน branch × งบต่อ branch 3 × 0.50 = 1.50 USD
+ j บวกค่า judge 1.50 + 0.10 = 1.60 USD

Summary

  • คำตัดสิน: น่าลองสำหรับนักพัฒนา Python ที่อยากได้ทั้งผู้ช่วยใน Terminal และ framework สร้าง Agent เอง
  • แก่น: create_deep_agent() ประกอบ planning, memory, subagents, context management ให้ด้วยแฟล็ก include_*
  • ต้องมี: Sandbox, งบค่าใช้จ่าย และการตรวจ diff ก่อนให้ Agent แก้งานจริง
  • ยังไม่ยืนยัน: ประโยชน์ของ Forking, คุณภาพเทียบเครื่องมืออื่น และเวอร์ชันล่าสุด (เลข commit ไม่ได้อ่าน)
  • ระวัง: เจ้าของ repo คือ vstorm-co และชื่อฟังก์ชันซ้ำกับ deepagents ของ LangChain
Facebook

ความรู้ที่เกี่ยวข้อง