คู่มือฉบับสมบูรณ์ของ Hermes Agent: สถาปัตยกรรม การตั้งค่า และวงจรการพัฒนาตนเอง

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

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

บทความนี้อธิบายวิธีการประกอบ Hermes วิธีการกำหนดค่า และวิธีการทำงานของลูปการปรับปรุงตนเองนั้นภายใต้ฝาครอบ

Hermes คืออะไร และแตกต่างจาก OpenClaw อย่างไร

Hermes คือเอเจนต์ AI ที่ทำงานบนระบบคลาวด์ มีโครงสร้างคล้ายกับ OpenClaw: มันทำงานตลอด 24 ชั่วโมงทุกวัน และคุณโต้ตอบกับมันผ่านแอปส่งข้อความแทนที่จะเป็นเทอร์มินัลหรือแท็บเบราว์เซอร์

ความแตกต่างที่สำคัญมีสามประการ

ประการแรก Hermes มาพร้อมกับคลังทักษะในตัวที่ใหญ่กว่ามากตั้งแต่แกะกล่อง ดังนั้นคุณจึงใช้เวลาน้อยลงในการเชื่อมต่อระบบต่างๆ ด้วยตัวเอง

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

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

การติดตั้งและการตั้งค่าเริ่มต้น

การทำให้ Hermes ทำงานนั้นใช้คำสั่งเดียวเท่านั้น

บน Windows ให้รันคำสั่งนี้ใน PowerShell:

iex (irm

https://hermes-agent.nousresearch.com/install.ps1

บน Linux, macOS หรือ WSL คำสั่งที่เทียบเท่าคือ:

curl -fsSL

https://hermes-agent.nousresearch.com/install.sh | bash

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

การเลือกและกำหนดเส้นทางของโมเดล

การตัดสินใจหลักอย่างแรกในการตั้งค่าคือผู้ให้บริการ LLM ใดที่จะเป็น "สมอง" ของเอเจนต์ การตรวจสอบสิทธิ์ทำผ่าน OAuth แทนที่จะเป็นคีย์ API ดิบ ซึ่งขยายไปถึงการสามารถเข้าสู่ระบบผ่านเซสชัน Claude Code หรือ Codex CLI ที่มีอยู่แล้ว แทนที่จะสร้างคีย์ API แยกต่างหาก

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

งานที่รองรับการแทนที่แบบนี้คือ:

• vision – การวิเคราะห์และอธิบายภาพ
• web_extract – การสรุปหน้าเว็บที่ยาว
• compression – การบีบอัดบริบทการสนทนาที่ล้นเกิน
• title_generation – การสร้างชื่อเซสชัน
• curator – เอเจนต์เบื้องหลังที่รับผิดชอบลูปการปรับปรุงตนเอง
• kanban_decomposer – การแบ่งงานขนาดใหญ่ออกเป็นงานย่อยในโหมด Kanban
• goal_judge – เอเจนต์ที่ตรวจสอบว่า /goal บรรลุผลจริงหรือไม่

การกำหนดค่านี้ทำได้โดยตรงในไฟล์ config.yaml ตัวอย่างเช่น:

1# Primary model for chat and complex reasoning
2model:
3  provider: "anthropic"
4  default: "claude-4-8-sonnet"
5  auxiliary:
6    vision:
7      provider: "gemini"
8      model: "gemini-2.5-flash"
9    compression:
10      provider: "custom"
11      base_url: "http://localhost:11434/v1"
12      api_key: "none"
13      model: "qwen2.5:32b"

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

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

เป็นที่น่าสังเกตว่าหากคุณต้องการประหยัดค่าใช้จ่ายในโมเดลการสนทนาโดยไม่ต้องเสียสละคุณภาพการเขียนโค้ด Hermes รองรับคำสั่ง /claude_code และ /codex ที่มอบหมายงานเขียนโค้ดให้กับเครื่องมือ CLI เหล่านั้นโดยตรง แทนที่จะจัดการด้วยโมเดลแชทที่กำหนดค่าไว้

แบ็กเอนด์เทอร์มินัล

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

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

ความปลอดภัยในที่นี้ขึ้นอยู่กับระบบอนุมัติในตัวทั้งหมดที่คอยสกัดกั้นคำสั่งที่อาจก่อให้เกิดความเสียหาย (เช่น rm -rf /, DROP TABLE) และขออนุญาตอย่างชัดแจ้งก่อนดำเนินการ

Docker จะรันเอเจนต์ภายในแซนด์บ็อกซ์ที่แยกออกมา ดังนั้นจึงไม่สามารถแตะต้องระบบโฮสต์ของคุณได้ SSH จะให้เอเจนต์ดำเนินการคำสั่งและทำงานกับไฟล์บนเซิร์ฟเวอร์ระยะไกลผ่านการเชื่อมต่อระยะไกล Modal จะรันทุกอย่างในแซนด์บ็อกซ์คลาวด์แบบไร้เซิร์ฟเวอร์ โดยคุณจะจ่ายค่าเช่าคอมพิวติ้งเป็นวินาที จ่ายเฉพาะวินาทีจริงที่โค้ดของคุณทำงาน

Daytona เป็นเลเยอร์การจัดการคอนเทนเนอร์ที่สร้างขึ้นโดยเฉพาะสำหรับเอเจนต์เขียนโค้ด AI มันเร็วกว่าการรัน Docker โดยตรงและจัดการการตั้งค่าสภาพแวดล้อมและการติดตั้ง dependencies โดยอัตโนมัติ

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

เกตเวย์การส่งข้อความและการกำหนดค่าเครื่องมือ

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

ส่วนที่เหลือของการตั้งค่าจะแนะนำให้คุณเปิดใช้งานเครื่องมือแต่ละอย่างและผู้ให้บริการตามลำดับ ได้แก่ ระบบอัตโนมัติของเบราว์เซอร์ การสร้างภาพ การแปลงข้อความเป็นเสียง และการค้นหาเว็บ สำหรับการค้นหาเว็บโดยเฉพาะ Firecrawl หรือ Exa ที่โฮสต์เองเป็นตัวเลือกที่โดดเด่นสำหรับการขูดข้อมูลและการดึงข้อมูลที่เน้นเอเจนต์

การค้นหา X จำเป็นต้องมีการสมัครสมาชิก Grok เพื่อเปิดใช้งาน ซึ่งเป็นสิ่งที่ควรรู้ก่อนที่จะไปหาในเมนู

คำสั่ง Slash ที่ควรรู้

Hermes มาพร้อมกับรายการคำสั่ง slash ที่ยาว ซึ่งส่วนใหญ่สามารถเข้าใจได้จากชื่อ แต่มีบางคำสั่งที่ควรกล่าวถึงเป็นพิเศษ

1. /background <prompt> รันงานในเบื้องหลังโดยไม่รบกวนเซสชันหลักของคุณ
2. /goal กำหนดเป้าหมายระยะยาวที่เอเจนต์จะทำงานอย่างต่อเนื่อง โดยมีคำสั่งย่อยสำหรับหยุดชั่วคราว ดำเนินการต่อ ล้าง หรือตรวจสอบสถานะ
3. /subgoal จัดการเป้าหมายย่อยที่ซ้อนอยู่ภายใต้เป้าหมายที่กำลังดำเนินการอยู่
4. /kanban จัดการงานระยะยาวแบบอะซิงโครนัสผ่านเอเจนต์อิสระหลายตัว โดยทำหน้าที่เหมือนบอร์ด Kanban จริง ซึ่งกลุ่มงานจะถูกกระจายไปยังเอเจนต์ผู้ปฏิบัติงาน และเคลื่อนผ่านสถานะที่ต้องทำ กำลังดำเนินการ และเสร็จสิ้น เมื่อถูกส่งต่อระหว่างกัน

ในด้านการพัฒนา /github_pr_workflow จัดการวงจรเต็มรูปแบบตั้งแต่สาขาจนถึงการรวมโค้ด รวมถึง CI, /github_code_review ตรวจสอบ pull requests และ /codebase_inspection วิเคราะห์การแยกย่อยภาษาและจำนวนบรรทัดของ repository /dogfood เป็นโหมด QA เฉพาะที่ค้นหาบั๊กในเว็บแอปและสร้างรายงานที่มีหลักฐานสนับสนุน /spike รันการทดลองที่รวดเร็วและทิ้งได้เพื่อตรวจสอบแนวคิดก่อนที่จะลงมือพัฒนาแบบเต็มรูปแบบ และ /systematic_debugging ทำงานผ่านบั๊กในสี่เฟส โดยทำความเข้าใจสาเหตุที่แท้จริงก่อนที่จะพยายามแก้ไข

นอกจากนี้ยังมีกลุ่มคำสั่งเฉพาะสำหรับการผสานรวม – /notion, /obsidian, /airtable, /google_workspace, /arxiv, /blogwatcher, /polymarket, /ocr_and_documents, /youtube_content – ซึ่งแต่ละคำสั่งครอบคลุมบริการภายนอกหรือเวิร์กโฟลว์เฉพาะ รวมถึง /bundles ซึ่งจัดกลุ่มทักษะที่มีอยู่หลายอย่างไว้ภายใต้คำสั่ง slash เดียวผ่านไฟล์การกำหนดค่า YAML ขนาดเล็ก

Cron jobs และ Webhooks

พื้นฐานระบบอัตโนมัติสองอย่างสมควรได้รับความสนใจเป็นพิเศษ

• Cron jobs ช่วยให้คุณกำหนดเวลาสคริปต์ให้รันตามตัวจับเวลา หากคุณส่งค่า -no-agent เมื่อสร้างมัน Hermes จะรันสคริปต์ Python หรือ bash ธรรมดาและส่งต่อเอาต์พุตไปยังแอปส่งข้อความของคุณเท่านั้น โดยไม่ต้องใช้โทเค็น LLM เลย
• Webhooks เป็นส่วนที่ทรงพลังกว่า: มันช่วยให้เอเจนต์สามารถตอบสนองต่อเหตุการณ์ภายนอกแทนที่จะเป็นตัวจับเวลา คุณสามารถกำหนดค่า webhook เพื่อให้ ตัวอย่างเช่น pull request ใหม่บน GitHub ทริกเกอร์เอเจนต์ด้วยพร้อมท์และชุดทักษะเฉพาะโดยอัตโนมัติ ซึ่งก็คือการตั้งค่าเอเจนต์ผู้ตรวจสอบที่เข้าประจำการโดยไม่ต้องมีการแทรกแซงด้วยตนเองต่อ PR เลย

Context Engines

Context engine ควบคุมวิธีการที่ Hermes บีบอัดและจัดการประวัติการสนทนาเมื่อเข้าใกล้ขีดจำกัดโทเค็นของโมเดล และมีสองตัวเลือกให้เลือก

• ค่าเริ่มต้น เรียกว่า Compressor จะใช้การสรุปแบบ lossy กับส่วนกลางของการสนทนาที่ยาว
• ทางเลือกอื่น คือ LCM (Lossless Context Management) ใช้แนวทางที่แตกต่างในเชิงโครงสร้าง: แทนที่จะสร้างสรุปข้อความ มันสร้างกราฟแบบมีทิศทางและไม่มีวงจรของประเด็นสำคัญในการสนทนา ทำให้เอเจนต์สามารถนำทางจากมุมมองระดับสูงที่ถูกบีบอัดอย่างหนัก ไปจนถึงข้อความต้นฉบับเฉพาะที่สนับสนุนประเด็นนั้น

Memory Engines

ผู้ให้บริการหน่วยความจำภายนอกทำงานควบคู่ไปกับไฟล์หน่วยความจำท้องถิ่นในตัวของ Hermes ซึ่งคือ MEMORY.md และ USER.md เพิ่มความสามารถเช่นการค้นหาเชิงความหมายและกราฟความรู้

สามารถกำหนดค่าหลายตัวได้โดยตรงผ่าน TUI การตั้งค่า

1. Honcho สร้างขึ้นจากการสร้างโปรไฟล์ผู้ใช้โดยละเอียด โดยใช้การเรียก LLM ในเบื้องหลังเพื่อสังเคราะห์การสังเกตการณ์ในสองชั้น: ชั้นฐานของสรุปเซสชันและโปรไฟล์ และชั้นวิภาษวิธีที่วิเคราะห์ความต้องการปัจจุบันของผู้ใช้
2. OpenViking คือฐานข้อมูลบริบทที่สร้างลำดับชั้นความรู้แบบระบบไฟล์ รองรับการดึงบริบทแบบหลายชั้น และจัดเรียงข้อเท็จจริงที่สกัดได้ออกเป็นหกประเภทโดยอัตโนมัติ – เหตุการณ์ รูปแบบ ความชอบ และอื่นๆ – เมื่อสิ้นสุดแต่ละเซสชัน
3. Mem0 คือบริการหน่วยความจำคลาวด์ที่มีการจัดการอย่างเต็มรูปแบบ การสกัดข้อเท็จจริงเกิดขึ้นที่ฝั่งเซิร์ฟเวอร์ผ่าน LLM และรวมถึงการค้นหาเชิงความหมาย การจัดอันดับผลลัพธ์ใหม่ และการกำจัดข้อมูลซ้ำซ้อนอัตโนมัติ แม้ว่าจะโฮสต์บนคลาวด์ ดังนั้นจึงเป็นตัวเลือกเดียวที่มีค่าใช้จ่ายที่เกิดขึ้นประจำ
4. Hindsight คือระบบหน่วยความจำระยะยาวขั้นสูงที่สร้างขึ้นบนกราฟความรู้ ในสไตล์ GraphRAG มันสกัดเอนทิตีจากเซสชัน สร้างความสัมพันธ์ระหว่างเอนทิตีเหล่านั้น และรักษาการสนทนาทั้งรอบรวมถึงการเรียกใช้เครื่องมือ โดยหน่วยความจำถูกแบ่งออกเป็นสี่ประเภท: ข้อเท็จจริงเกี่ยวกับโลก ประสบการณ์ของเอเจนต์เอง ความคิดเห็น และการสังเกตการณ์
5. Holographic คือคลังข้อเท็จจริงในเครื่องที่ใช้ SQLite โดยไม่มี dependencies ภายนอก รวมถึงระบบการให้คะแนนความน่าเชื่อถือสำหรับข้อเท็จจริงที่เก็บไว้ และการใช้ Holographic Reduced Representations เพื่อรองรับการสืบค้นเชิงพีชคณิตและเชิงองค์ประกอบ โดยมีความสามารถในการตรวจจับความขัดแย้งภายในฐานความรู้โดยอัตโนมัติ
6. RetainDB คือ API คลาวด์สำหรับหน่วยความจำของทีม นำเสนอการค้นหาแบบผสมระหว่างเวกเตอร์ BM25 และวิธีการจัดอันดับใหม่ โดยหน่วยความจำถูกแบ่งออกเป็นเจ็ดประเภทที่แตกต่างกัน และใช้การบีบอัดเดลต้าเพื่อให้การจัดเก็บมีประสิทธิภาพ
7. ByteRover คือระบบหน่วยความจำท้องถิ่นแบบพกพาที่เข้าถึงได้ผ่าน CLI สร้างแผนผังความรู้แบบลำดับชั้น และสกัดข้อเท็จจริงที่สำคัญก่อนที่การบีบอัดแบบ lossy จะมีโอกาสทิ้งพวกมันจากบริบท
8. Supermemory นำเสนอหน่วยความจำระยะยาวเชิงความหมายพร้อม API กราฟ: มันกินบันทึกเซสชันทั้งหมดหลังจากที่การสนทนาสิ้นสุดลงเพื่อสร้างกราฟความรู้ ทำความสะอาดข้อเท็จจริงที่ถูกเรียกคืนเป็นระยะเพื่อหลีกเลี่ยงการปนเปื้อนจากเทิร์นปัจจุบัน และสามารถแยกหน่วยความจำออกเป็นคอนเทนเนอร์แยกต่างหากต่อโปรไฟล์เอเจนต์

สำหรับการใช้งานในชีวิตประจำวัน หน่วยความจำท้องถิ่นเริ่มต้นนั้นเพียงพอสำหรับคนส่วนใหญ่จริงๆ – ระบบที่หนักกว่าจะแลกต้นทุนทรัพยากรจริง โดยเฉพาะ RAM สำหรับตัวเลือกที่โฮสต์ในเครื่อง กับความสามารถที่เวิร์กโฟลว์ส่วนใหญ่ยังไม่ต้องการ

ลูปการปรับปรุงตนเอง

นี่คือฟีเจอร์ที่ทำให้ Hermes แตกต่างจากเอเจนต์ทั่วไปมากที่สุด: ชุดของกระบวนการเบื้องหลังแบบอะซิงโครนัสที่วิเคราะห์การสนทนาของคุณอย่างต่อเนื่อง ดึงรูปแบบที่มีประโยชน์ออกมา และเขียนรูปแบบเหล่านั้นลงในหน่วยความจำระยะยาวและหน่วยความจำเชิงกระบวนการ (ทักษะ) จากนั้นจึงบำรุงรักษาความรู้ที่สะสมไว้เพื่อไม่ให้เสื่อมลงเมื่อเวลาผ่านไป ทั้งระบบทำงานควบคู่ไปกับแชทหลักของคุณและสร้างขึ้นจากสามองค์ประกอบ: ระบบทริกเกอร์ เอเจนต์ตรวจสอบเบื้องหลัง และ curator

• ระบบทริกเกอร์

Hermes ไม่ได้วิเคราะห์ทุกข้อความแบบเรียลไทม์ เพราะนั่นจะสิ้นเปลืองโทเค็นโดยไม่มีประโยชน์ แต่จะอาศัยตัวนับสองตัวที่จะทริกเกอร์รอบการสะท้อนกลับเมื่อข้ามเกณฑ์ที่กำหนด

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

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

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

• เอเจนต์ตรวจสอบเบื้องหลัง

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

1. ในด้านการประกาศ (declarative) หากมันสังเกตเห็นการตั้งค่าหรือรายละเอียดสภาพแวดล้อมใหม่ของผู้ใช้ – ความชอบสำหรับ Supabase, โปรเจกต์ที่ตรึงกับ Python 3.12 – มันจะอัปเดต MEMORY.md หรือ USER.md ขึ้นอยู่กับว่าไฟล์ใดที่ข้อเท็จจริงนั้นควรอยู่
2. ในด้านเชิงกระบวนการ (procedural) หากมันตรวจพบว่าเอเจนต์เพิ่งแก้ปัญหาที่ไม่ใช่เรื่องเล็กน้อยหรือคิดค้นกระบวนการที่ซับซ้อน มันสามารถสร้างทักษะใหม่ แก้ไขทักษะที่มีอยู่ ใช้แพตช์ที่ตรงเป้าหมาย หรือลบทิ้งทั้งหมด ทักษะใดๆ ที่มันสร้างขึ้นจะถูกแท็กอย่างชัดเจนว่าสร้างโดยเอเจนต์ ดังนั้นที่มาของทักษะจึงสามารถตรวจสอบย้อนกลับได้เสมอ

เพื่อให้ curator สามารถตัดสินใจได้ในที่สุดว่าทักษะที่สร้างขึ้นเองเหล่านี้ใดบ้างที่คุ้มค่าที่จะเก็บไว้ Hermes จะรักษาบันทึกการใช้งานที่ซ่อนอยู่ซึ่งติดตามสำหรับทุกทักษะ: จำนวนครั้งที่ถูกโหลดลงในพร้อมท์ จำนวนครั้งที่เอเจนต์เปิดเพื่ออ่าน จำนวนครั้งที่ถูกแก้ไข และเวลาที่สร้าง ใช้งานล่าสุด และแก้ไขล่าสุด

• Curator

หากปล่อยไว้โดยไม่ตรวจสอบ กระบวนการนี้อาจก่อให้เกิดทักษะหลายร้อยทักษะในที่สุด บางทักษะซ้ำซ้อน บางทักษะล้าสมัย

curator มีอยู่เพื่อป้องกันไม่ให้ฐานความรู้เสื่อมลง มันจะเริ่มทำงานก็ต่อเมื่อเงื่อนไขสองข้อเป็นจริงพร้อมกัน: ผ่านไปนานเพียงพอตั้งแต่การทำงานครั้งล่าสุด (เจ็ดวันโดยค่าเริ่มต้น) และเอเจนต์หลักได้หยุดทำงานนานพอ (สองชั่วโมงโดยค่าเริ่มต้น) เพื่อให้รอบการบำรุงรักษาที่หนักหน่วงไม่รบกวนงานที่กำลังทำอยู่

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

งานของ curator เกิดขึ้นในสองเฟส:

• เฟสแรกเป็นเชิงกลไกล้วนๆ และไม่เกี่ยวข้องกับการเรียก LLM เลย: มันตรวจสอบเมตริกการใช้งาน ทำเครื่องหมายทักษะใดๆ ที่สร้างโดยเอเจนต์และไม่ได้ใช้งานนานกว่า 30 วันว่าเลิกใช้แล้ว และย้ายสิ่งใดก็ตามที่ไม่ได้ใช้งานนานกว่า 90 วันไปยังโฟลเดอร์ที่เก็บถาวร ทักษะที่สำคัญสามารถปักหมุดไว้อย่างชัดเจนเพื่อป้องกันจากกระบวนการนี้
• เฟสที่สองคือการตรวจสอบ LLM จริง ซึ่งรันผ่านอินสแตนซ์เอเจนต์แยกต่างหากที่แยกออกมา โดยใช้โมเดลใดก็ได้ที่กำหนดค่าสำหรับงานเสริมของ curator – โดยค่าเริ่มต้นเป็นโมเดลเดียวกับการสนทนาหลัก แม้ว่าจะสามารถชี้ไปที่สิ่งที่ถูกกว่าได้ก็ตาม ควรใช้ความระมัดระวังในการเลือกสิ่งที่ถูกเกินไป เนื่องจากคุณภาพของการตัดสินใจเหล่านี้มีผลกระทบต่อเนื่องจริงต่อคลังทักษะ

สำหรับแต่ละทักษะ curator ตัดสินใจที่จะเก็บไว้เหมือนเดิมหากยังถูกต้องและมีประโยชน์ แก้ไขหากมีข้อผิดพลาดหรือวิธีการที่ล้าสมัย รวมกับทักษะอื่นที่ครอบคลุมเนื้อหาเดียวกันเป็นส่วนใหญ่ (โดยย้ายสคริปต์ การประเมิน หรือไฟล์อ้างอิงที่เกี่ยวข้องอย่างถูกต้อง และเขียนเส้นทางสัมพัทธ์ใหม่ในกระบวนการ) หรือเก็บถาวรทิ้งไปเลย

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

การใช้ Hermes อย่างมีประสิทธิภาพ

เอเจนต์บนคลาวด์เช่นนี้มีประโยชน์อย่างแท้จริงสำหรับกระบวนการใดๆ ที่คุณสามารถรันได้ตลอด 24 ชั่วโมงทุกวัน – โดยงานเขียนโค้ดเป็นข้อยกเว้นที่โดดเด่น – โดยมีเงื่อนไขว่าคุณได้แปลงกระบวนการนั้นเป็นดิจิทัลอย่างระมัดระวังและสร้างทักษะที่ดีรอบๆ กระบวนการนั้น รวมถึงการประเมินด้วย

เวิร์กโฟลว์ที่มักจะให้ผลลัพธ์ที่ดีมีลักษณะดังนี้:

1. เริ่มต้นด้วยการบันทึกตัวคุณเอง โดยละเอียด โดยดำเนินการตามกระบวนการตั้งแต่ต้นจนจบอย่างสมบูรณ์ โดยควรใช้เครื่องมือบันทึกเสียงเพื่อให้คุณจับภาพได้อย่างแม่นยำ – และขั้นตอนนี้จะได้ผลก็ต่อเมื่อคุณเข้าใจกระบวนการอย่างแท้จริงหรือได้ค้นคว้าอย่างถูกต้องเท่านั้น
2. นำการบันทึกหรือบันทึกย่อนั้นไปป้อนให้กับเอเจนต์เขียนโค้ดโดยใช้เครื่องมือสร้างทักษะเพื่อสร้างร่างแรก มันจะยังไม่ดีพอที่จะส่งต่อ โดยเฉพาะอย่างยิ่งสำหรับสิ่งที่ซับซ้อน
3. สร้างการประเมิน (evals) – โซลูชันอ้างอิงที่แสดงถึงผลลัพธ์ที่ถูกต้อง – เนื่องจากมันช่วยให้คุณวัดได้จริงว่าทักษะทำงานได้ดีหรือไม่ แทนที่จะเดา
4. รันทักษะในสภาพแวดล้อมทดสอบและปรับปรุงทั้งการประเมินและเนื้อหาทักษะตามสิ่งที่คุณสังเกต โดยแก้ไขส่วนใหญ่ด้วยตนเองแทนที่จะมอบหมายให้คนอื่นทำ
5. เมื่อทักษะทำงานอย่างสม่ำเสมอและแน่นอนแล้วเท่านั้น จึงควรส่งมอบให้กับเอเจนต์ที่ทำงานตลอดเวลา หากกระบวนการขึ้นอยู่กับบริการภายนอกบางอย่าง ควรตรวจสอบว่ามี MCP server หรือ CLI ที่มีอยู่แล้วครอบคลุมบริการนั้นหรือไม่ ก่อนที่จะสร้างขึ้นมาใหม่ตั้งแต่ต้น

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

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

หากข้อมูลนี้มีประโยชน์ – บุ๊กมาร์กไว้ คุณจะอยากกลับมาดูอีกครั้ง

สำหรับบทวิเคราะห์เพิ่มเติมแบบนี้ ติดตาม @ScottyBeamIO

ไม่มีน้ำ ไม่มีอะไรที่ไม่จำเป็น มีแต่สิ่งที่ใช้ได้จริง