เจาะลึก Hermes Agent ปี 2026: เอเจนต์ AI ที่พัฒนาตัวเองได้และจำคุณได้จริง ๆ

คุณน่าจะเคยเห็น Hermes Agent บน GitHub Trending กันมาบ้างแล้ว — มีดาว 73,000+ ดวง และกำลังเพิ่มขึ้นอย่างรวดเร็ว โปรเจกต์นี้สร้างโดย Nous Research (แล็บที่อยู่เบื้องหลังโมเดลตระกูล Hermes และ Nomos) เป็น open-source AI agent ที่รันบนฮาร์ดแวร์ของคุณเอง ไม่ใช่แค่เปลือกครอบ chatbot ไม่ใช่ plugin บน IDE แต่มันคือเอเจนต์อัตโนมัติเต็มรูปแบบที่มีหน่วยความจำ, การตั้งเวลา, การใช้เครื่องมือ, และ learning loop ที่จะเก่งขึ้นเรื่อย ๆ ยิ่งใช้งานนานเท่าไหร่

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

Hermes Agent คืออะไรกันแน่

Hermes Agent คือ AI agent ที่ self-host อาศัยอยู่บนเซิร์ฟเวอร์ของคุณ (หรือแล็ปท็อป, หรือ VPS ราคา $5) และคุยกับคุณผ่าน terminal, Telegram, Discord, Slack, WhatsApp, Signal — รวมแล้วกว่า 15 แพลตฟอร์มจาก gateway process เพียงตัวเดียว มันสามารถใช้ LLM ที่คุณต้องการได้หมด ไม่ว่าจะเป็น OpenAI, Anthropic, DeepSeek, Nous Portal, OpenRouter ที่มีโมเดลกว่า 200 ตัว, หรือ endpoint ที่คุณรันเองในเครื่อง

จุดขายที่ทำให้มันแตกต่างจาก "agent framework ทั่ว ๆ ไป" คือ: มันมี closed learning loop มันสามารถจำสิ่งต่าง ๆ ข้าม session, สร้าง skill ที่ใช้ซ้ำได้จากงานที่ซับซ้อน, พัฒนา skill เหล่านั้นระหว่างการใช้งาน, และสร้างโปรไฟล์เกี่ยวกับตัวตนของคุณไปเรื่อย ๆ เอเจนต์ส่วนใหญ่จะเริ่มต้นใหม่ทุกครั้งที่คุยกัน แต่ Hermes จะสะสม context ไปเรื่อย ๆ

มันเป็น MIT-licensed ซึ่งสำคัญมากถ้าคุณจะนำไปต่อยอด

ตัวเลขที่น่าสนใจ:

73,600+ GitHub stars (ข้อมูล ณ เดือนเมษายน 2026)
647 skills จาก 4 registries (79 skill ติดตั้งมาให้, 47 skill เป็นตัวเลือกเสริม, 521 skill จาก community)
15+ แพลตฟอร์ม messaging ที่รองรับจาก gateway เดียว
6 terminal backends: local, Docker, SSH, Daytona, Singularity, Modal
ข้อกำหนด context ขั้นต่ำ: 64K tokens (โมเดลที่ต่ำกว่านี้จะถูกปฏิเสธตอน khởi động)

การติดตั้ง: 60 วินาที ไม่ได้ล้อเล่น

# ติดตั้งด้วยคำสั่งเดียว — Linux, macOS, WSL2, หรือแม้แต่ Android ผ่าน Termux
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# รีโหลด shell ของคุณ
source ~/.bashrc  # หรือ: source ~/.zshrc

# เริ่มคุยได้เลย
hermes

ตัวติดตั้งจัดการให้ทุกอย่าง: Python 3.11 (ผ่าน uv, ไม่ต้องใช้ sudo), Node.js v22, ripgrep, ffmpeg สิ่งเดียวที่ต้องมีก่อนคือ git

หลังติดตั้ง คุณจะได้ชุดคำสั่ง CLI ที่ครอบคลุมการตั้งค่าส่วนใหญ่:

hermes model    # เลือกผู้ให้บริการ LLM ของคุณแบบ interactive
hermes tools    # เปิด/ปิดกลุ่มเครื่องมือ
hermes setup    # Wizard ตั้งค่าทั้งหมด (ทำทุกอย่างในครั้งเดียว)
hermes gateway  # เริ่ม messaging gateway
hermes doctor   # ตรวจสอบปัญหา
hermes update   # อัปเดตเป็นเวอร์ชันล่าสุด

ใช้บน Android ได้ด้วย Termux มี path การติดตั้งเฉพาะพร้อมกับ .[termux] extra ที่คัดสรรมาแล้ว ซึ่งจะข้าม dependency ด้านเสียงที่เข้ากันไม่ได้กับ Android คุณสามารถรัน AI agent จากมือถือของคุณได้จริง ๆ

การเลือกผู้ให้บริการโมเดล

Hermes ไม่ได้ผูกมัดคุณไว้กับผู้ให้บริการรายใดรายหนึ่ง แค่รัน hermes model แล้วเลือกจากลิสต์:

Provider	คืออะไร	วิธี Auth
Nous Portal	แบบ subscription, ไม่ต้องตั้งค่า	OAuth login
OpenAI Codex	ChatGPT OAuth, โมเดล Codex	Device code auth
Anthropic	โมเดล Claude โดยตรง	Claude Code auth หรือ API key
OpenRouter	200+ โมเดล, จากหลายผู้ให้บริการ	API key
DeepSeek	Direct API	API key
GitHub Copilot	GPT-5.x, Claude, Gemini ผ่าน Copilot	OAuth
Hugging Face	20+ open models	HF_TOKEN
Custom Endpoint	VLLM, SGLang, Ollama, หรืออะไรก็ตามที่เข้ากันได้กับ OpenAI	Base URL + key

และยังมี: Z.AI/GLM, Kimi/Moonshot, MiniMax, Alibaba Cloud/DashScope, Arcee AI, และอื่น ๆ

กฎ 64K: Hermes ต้องการ context อย่างน้อย 64,000 tokens โมเดลที่มีน้อยกว่านี้จะถูกปฏิเสธตอนเริ่มต้นระบบ ซึ่งก็สมเหตุสมผล — workflow ที่ต้องเรียกใช้เครื่องมือหลายขั้นตอนกิน context อย่างรวดเร็ว และถ้าหน้าต่าง context เล็กเกินไป เอเจนต์ก็จะลืมไปว่ากำลังทำอะไรอยู่กลางคัน ถ้าคุณรันโมเดลในเครื่อง ให้ตั้งค่า --ctx-size 65536 หรือสูงกว่า

คุณสามารถเปลี่ยนผู้ให้บริการได้ตลอดเวลาด้วย hermes model ไม่ต้องแก้โค้ด ไม่มีการผูกมัด

ระบบ Memory: เล็ก, มีขอบเขต และออกแบบมาอย่างจงใจ

นี่คือจุดที่ Hermes แตกต่างจาก agent framework ส่วนใหญ่ แทนที่จะโยนทุกอย่างลงใน vector database, Hermes กลับใช้ไฟล์เล็ก ๆ สองไฟล์ที่มีการจำกัดจำนวนตัวอักษร:

ไฟล์	จุดประสงค์	ขีดจำกัด
`MEMORY.md`	โน้ตของเอเจนต์ — ข้อมูลเกี่ยวกับ environment, ข้อตกลง, บทเรียนที่ได้เรียนรู้	2,200 ตัวอักษร (~800 tokens)
`USER.md`	โปรไฟล์ผู้ใช้ — ความชอบของคุณ, สไตล์การสื่อสาร	1,375 ตัวอักษร (~500 tokens)

ทั้งสองไฟล์อยู่ใน ~/.hermes/memories/ และจะถูกฉีดเข้าไปใน system prompt เป็น frozen snapshot ตอนที่ session เริ่มต้น

Memory ทำงานจริง ๆ อย่างไร:

══════════════════════════════════════════════
MEMORY (your personal notes) [67% — 1,474/2,200 chars]
══════════════════════════════════════════════
User's project is a Rust web service at ~/code/myapi using Axum + SQLx
§This machine runs Ubuntu 22.04, has Docker and Podman installed
§User prefers concise responses, dislikes verbose explanations

เอเจนต์จัดการ memory ของตัวเองผ่าน 3 action:

add — เก็บข้อมูลใหม่
replace — อัปเดตข้อมูลที่มีอยู่ (จับคู่จาก substring)
remove — ลบสิ่งที่ไ่ม่เกี่ยวข้องแล้ว

ข้อควรระวังของ frozen snapshot: เมื่อ Hermes เขียนข้อมูลลง memory ระหว่าง session การเปลี่ยนแปลงจะถูกบันทึกลงดิสก์ทันที — แต่มันจะไม่ปรากฏใน system prompt จนกว่าจะเริ่ม session ถัดไป นี่เป็นความตั้งใจ (เพื่อรักษา LLM prefix cache ไว้สำหรับ performance) แต่ก็หมายความว่าเอเจนต์อาจจะ "ลืม" สิ่งที่เพิ่งเรียนรู้ไปถ้าคุณยังคุยต่อใน session เดิม

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

อะไรควรบันทึก vs อะไรไม่ต้อง:

✅ ควรบันทึก: ความชอบของผู้ใช้, ข้อมูล environment, ข้อตกลงในโปรเจกต์, สิ่งที่แก้ไขให้ถูกต้อง, รูปแบบ workflow
❌ ไม่ต้องบันทึก: ข้อมูลเล็ก ๆ น้อย ๆ, ข้อมูลที่ค้นหาได้ง่าย, code block ขนาดใหญ่, ข้อมูลชั่วคราวสำหรับ session นั้น ๆ

แนวทางที่มีขอบเขตจำกัดแบบนี้เป็นอะไรที่สดชื่นดี ระบบ memory ของเอเจนต์ส่วนใหญ่มักจะไม่มีขีดจำกัด (แล้วก็เต็มไปด้วยขยะ) หรือไม่ก็ใช้ vector retrieval (ซึ่งมักจะจินตนาการความเกี่ยวข้องไปเอง) แต่ Hermes บังคับให้มีวินัย

Skills: ความจำเชิงกระบวนการที่เอเจนต์สร้างขึ้นเอง

Skills คือคำตอบของ Hermes สำหรับคำถามที่ว่า "จะเก่งขึ้นในงานที่ทำซ้ำ ๆ ได้อย่างไร?" เมื่อเอเจนต์ทำงานที่ซับซ้อนเสร็จ มันสามารถสร้าง skill ขึ้นมาได้ — ซึ่งก็คือไฟล์ SKILL.md ที่มีคำแนะนำสำหรับครั้งต่อไป Skills จะพัฒนาตัวเองได้ระหว่างการใช้งาน

ecosystem ของมันใหญ่โตน่าประหลาดใจ: มี 647 skills จาก 4 registries ที่มีมาให้ในตัวครอบคลุม:

Coding agents: การมอบหมายงานให้ Claude Code, Codex, OpenCode
Creative tools: ศิลปะ ASCII, ศิลปะ generative ด้วย p5.js, อนิเมชันคณิตศาสตร์ด้วย Manim, ไดอะแกรม Excalidraw, ไดอะแกรมสถาปัตยกรรม
Platform integrations: Apple Notes, Apple Reminders, FindMy, iMessage
ของสนุก ๆ: การตั้งค่าเซิร์ฟเวอร์ modpack ของ Minecraft, ผู้เล่น Pokemon (ใช่ครับ มันเล่น Pokemon ได้เองแบบอัตโนมัติผ่าน headless emulation)
Design: 54 เทมเพลต design system คุณภาพระดับ production ที่ดึงมาจากเว็บจริง (Stripe, Linear, Vercel, Notion, Airbnb…)

Skills เป็นไปตามมาตรฐานเปิด agentskills.io ทำให้สามารถพกพาและแบ่งปันกันใน community ได้

สถานการณ์จริง: คุณขอให้ Hermes ตั้งค่า Docker Compose stack สำหรับแอป Postgres + Redis + Node มันทำเสร็จ แล้วก็สร้าง skill ชื่อ "docker-compose-setup" ขึ้นมาพร้อมกับเทมเพลต, ปัญหาที่เจอบ่อย ๆ, และข้อตกลงเรื่อง port ที่มันค้นพบ ครั้งต่อไปที่คุณขอ stack ที่คล้ายกัน มันจะโหลด skill นี้ขึ้นมาแล้วทำงานเสร็จโดยใช้ขั้นตอนน้อยลงครึ่งหนึ่ง

Tools: 47 อย่างที่มาพร้อมใช้งาน จัดเรียงตามหมวดหมู่

Hermes มาพร้อมกับ tool registry ที่กว้างขวาง คุณสามารถเปิด/ปิดกลุ่มเครื่องมือได้ด้วย hermes tools:

หมวดหมู่	ตัวอย่าง	ใช้ทำอะไร
Web	`web_search`, `web_extract`	ค้นหาและดึงข้อมูลจากเว็บ
Terminal & Files	`terminal`, `process`, `read_file`, `patch`	รันคำสั่ง, แก้ไขไฟล์
Browser	`browser_navigate`, `browser_snapshot`, `browser_vision`	ควบคุมเบราว์เซอร์เต็มรูปแบบ
Media	`vision_analyze`, `image_generate`, `text_to_speech`	วิเคราะห์ภาพ, สร้างภาพ, แปลงข้อความเป็นเสียง
Agent orchestration	`todo`, `execute_code`, `delegate_task`	การวางแผน, subagents, การรันโค้ด
Memory & recall	`memory`, `session_search`	หน่วยความจำถาวร, การค้นหาข้าม session
Automation	`cronjob`, `send_message`	งานที่ตั้งเวลาไว้, การส่งข้อความออก

เปิด/ปิดอย่างรวดเร็ว:

# เริ่มด้วยเครื่องมือ web และ terminal เท่านั้น
hermes chat --toolsets "web,terminal"

# หรือตั้งค่าแบบ interactive
hermes tools

Terminal Backends: รันได้ทุกที่ อย่างปลอดภัย

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

Backend	กรณีใช้งาน
`local`	ค่าเริ่มต้น — รันบนเครื่องของคุณ
`docker`	container ที่แยกขาด — ปลอดภัยสำหรับงานที่ไม่น่าไว้ใจ
`ssh`	เซิร์ฟเวอร์ระยะไกล — เอเจนต์ไม่สามารถยุ่งกับโค้ดของตัวเองได้
`daytona`	Cloud sandbox — คงอยู่ถาวร, พักการทำงานเมื่อไม่ได้ใช้
`modal`	Serverless — สเกลได้, จ่ายตามการใช้งาน
`singularity`	HPC containers — สำหรับ cluster computing แบบ rootless

# ~/.hermes/config.yaml
terminal:
  backend: docker
  docker_image: python:3.11-slim
  container_persistent: true  # packages จะยังอยู่ข้าม session
  container_cpu: 1
  container_memory: 5120      # 5GB

SSH backend เป็นจุดที่ลงตัวที่สุดในเรื่องความปลอดภัย: เอเจนต์จะทำงานบนเครื่องระยะไกลและไม่สามารถแก้ไขโค้ดหรือ config ของตัวเองได้อย่างสิ้นเชิง Container backends (Docker, Singularity, Modal) เพิ่มความแข็งแกร่งเข้าไปอีก: root filesystem แบบอ่านอย่างเดียว, ตัด Linux capabilities ทั้งหมดทิ้ง, ไม่มีการยกระดับสิทธิ์, จำกัด PID, และแยก namespace โดยสมบูรณ์

เคล็ดลับการใช้งานจริง: ถ้าคุณรัน Hermes บน VPS และให้มันทำงานจริง ๆ ให้เริ่มด้วย docker backend ถ้าคุณไว้ใจงานแต่ต้องการการแยกส่วน ให้ใช้ ssh ใช้ local เฉพาะตอนพัฒนาหรือสำหรับงานที่คุณจะรันด้วยตัวเองเท่านั้น

Cron: ระบบอัตโนมัติแบบตั้งเวลาในตัว

Hermes มีตัวตั้งเวลา cron ในตัว ไม่ต้องใช้เครื่องมือภายนอก สร้าง job ด้วยภาษามนุษย์หรือ cron expression แล้วผลลัพธ์จะถูกส่งไปยังแพลตฟอร์ม messaging ใดก็ได้

# จากในแชท
/cron add "every 6h" "Check GitHub trending repos in Python and summarize the top 5 new ones. If nothing interesting, respond with [SILENT]." --name "GitHub watcher" --deliver telegram

# จาก CLI
hermes cron create "0 9 * * 1" \
  "Generate a weekly report of top AI news, trending ML repos, and most-discussed HN posts." \
  --name "Weekly AI digest" \
  --deliver telegram

สิ่งสำคัญที่ต้องเข้าใจ: Cron jobs จะรันใน agent session ใหม่ที่ไม่มี memory จากแชทปัจจุบันของคุณ Prompt จะต้องสมบูรณ์ในตัวเองอย่างสิ้นเชิง เรื่องนี้ทำคนสับสนกันเยอะ — พวกเขาเขียน cron prompt แบบ "ทำสิ่งที่เราคุยกันไว้นั่นแหละ" แล้วก็สงสัยว่าทำไมเอเจนต์ถึงไม่รู้ว่าหมายถึงอะไร

พารามิเตอร์ --script คือท่าไม้ตาย คุณสามารถแนบ Python script ที่จะรันก่อนการทำงานแต่ละครั้งได้ stdout ของมันจะกลายเป็น context ให้กับเอเจนต์:

# ~/.hermes/scripts/watch-site.py
import hashlib, json, os, urllib.request

URL = "https://example.com/pricing"
STATE_FILE = os.path.expanduser("~/.hermes/scripts/.watch-state.json")

content = urllib.request.urlopen(URL, timeout=30).read().decode()
current_hash = hashlib.sha256(content.encode()).hexdigest()

# โหลด state ก่อนหน้า
prev_hash = None
if os.path.exists(STATE_FILE):
    with open(STATE_FILE) as f:
        prev_hash = json.load(f).get("hash")

# บันทึก state ปัจจุบัน
with open(STATE_FILE, "w") as f:
    json.dump({"hash": current_hash, "url": URL}, f)

if prev_hash and prev_hash != current_hash:
    print(f"CHANGE DETECTED on {URL}")
    print(f"Content preview:\n{content[:2000]}")
else:
    print("NO_CHANGE")

/cron add "every 1h" "If script says CHANGE DETECTED, summarize what changed. If NO_CHANGE, respond with [SILENT]." --script ~/.hermes/scripts/watch-site.py --name "Pricing monitor" --deliver telegram

ทริค [SILENT]: เมื่อคำตอบของเอเจนต์มี [SILENT] อยู่ การส่งข้อความจะถูกระงับ คุณจะได้รับการแจ้งเตือนก็ต่อเมื่อมีบางอย่างเกิดขึ้นจริง ๆ เท่านั้น ไม่มีการสแปม

Messaging Gateway: คุยกับมันได้จากมือถือของคุณ

hermes gateway setup  # แบบ interactive — เลือกแพลตฟอร์มของคุณ
hermes gateway        # เริ่ม gateway process

Hermes รองรับ 15+ แพลตฟอร์ม messaging จาก gateway เดียว: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, DingTalk, Feishu, WeCom, BlueBubbles, Home Assistant, และ Open WebUI

ตัวอย่างการตั้งค่า Telegram (ที่นิยมที่สุด):

สร้างบอทผ่าน @BotFather (/newbot)
รับ user ID ของคุณผ่าน @userinfobot
รัน hermes gateway setup, เลือก Telegram, วาง token และ user ID
เริ่ม gateway: hermes gateway

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

ข้อความเสียงก็ใช้ได้ — ส่งข้อความเสียงทาง Telegram, Hermes จะถอดเสียงเป็นข้อความให้โดยอัตโนมัติด้วย faster-whisper (รันในเครื่อง, ฟรี) แล้วตอบกลับข้อความนั้น

เคล็ดลับสำหรับกรุ๊ปแชท: บอท Telegram จะเปิด privacy mode ไว้เป็นค่าเริ่มต้น — บอทจะเห็นเฉพาะ /commands และการตอบกลับโดยตรงเท่านั้น ถ้าอยากให้มันเห็นทุกข้อความในกลุ่ม ให้ปิด privacy mode ใน BotFather หรือไม่ก็ตั้งบอทเป็น admin

การเชื่อมต่อ MCP: ขยายความสามารถด้วยเครื่องมือภายนอก

Hermes รองรับ Model Context Protocol (MCP) — คุณสามารถเชื่อมต่อกับ MCP server ใดก็ได้เพื่อเพิ่มเครื่องมือ:

# ~/.hermes/config.yaml
mcp:
  servers:
    - name: "github"
      command: "npx"
      args: ["-y", "@modelcontextprotocol/server-github"]
      env:
        GITHUB_TOKEN: "your-token"

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

Security: ป้องกัน 7 ชั้นแบบลึกซึ้ง

Hermes มีโมเดลการป้องกันเชิงลึก (defense-in-depth) ของจริง ไม่ใช่แค่ "เราเพิ่มหน้าจอให้กดยืนยันแล้วนะ":

User authorization — allowlists ควบคุมว่าใครสามารถคุยกับเอเจนต์ได้
Dangerous command approval — ต้องให้คนอนุมัติ (human-in-the-loop) สำหรับคำสั่งที่อันตราย (rm -rf, chmod 777, เป็นต้น)
Container isolation — Docker/Singularity/Modal พร้อมการตั้งค่าที่แข็งแกร่ง
MCP credential filtering — การแยก env var สำหรับ MCP subprocesses
Context file scanning — การตรวจจับ prompt injection ในไฟล์โปรเจกต์
Cross-session isolation — session ไม่สามารถเข้าถึงข้อมูลของกันและกันได้
Input sanitization — พารามิเตอร์ของ working directory จะถูกตรวจสอบกับ allowlist

โหมดการอนุมัติ:

# ~/.hermes/config.yaml
approvals:
  mode: manual   # manual | smart | off
  timeout: 60    # วินาทีก่อนจะปฏิเสธอัตโนมัติ

manual (ค่าเริ่มต้น): ถามก่อนรันคำสั่งอันตรายเสมอ
smart: ใช้ LLM ช่วยประเมินความเสี่ยง — อนุมัติความเสี่ยงต่ำอัตโนมัติ, ปฏิเสธความเสี่ยงสูงอัตโนมัติ, ส่งต่อสิ่งที่ไม่แน่ใจให้คนตัดสินใจ
off / --yolo: ข้ามการตรวจสอบทั้งหมด ใช้ใน CI/CD หรือ container ที่ใช้แล้วทิ้งเท่านั้น

Timeout เป็นแบบ fail-closed: ถ้าคุณไม่ตอบภายใน 60 วินาที คำสั่งจะถูกปฏิเสธ ไม่ใช่อนุมัติ นี่คือค่าเริ่มต้นที่ถูกต้อง

Subagents: แบ่งงานและทำงานแบบขนาน

Hermes สามารถสร้าง subagents ที่แยกจากกันเพื่อทำงานแบบขนานได้:

❯ Research these three topics simultaneously:
  1. Latest Rust async runtime benchmarks
  2. PostgreSQL 17 new features
  3. Best practices for LLM caching in production

แต่ละ subagent จะมี session, เครื่องมือ, และ context เป็นของตัวเอง ผลลัพธ์จะถูกส่งกลับมาที่ตัวแม่ นี่มีประโยชน์สำหรับงานที่ทำแบบขนานได้โดยธรรมชาติ — การค้นคว้า, การประมวลผลแบบ batch, การทำงานกับหลาย repo

คุณยังสามารถใช้ execute_code เพื่อเขียน Python script ที่เรียกใช้เครื่องมือผ่าน RPC ได้ ซึ่งช่วยย่อ pipeline หลายขั้นตอนให้กลายเป็น turn ที่ไม่เสีย context เลย

ข้อเสียจริง ๆ (พูดกันตามตรง)

รีวิวที่บอกแต่ข้อดีนั้นไร้ประโยชน์ นี่คือสิ่งที่สร้างปัญหาจริง ๆ:

1. Memory เล็กมากและต้องคอยจัดการอยู่เสมอ

2,200 ตัวอักษรสำหรับ agent memory 1,375 สำหรับ user profile นั่นคือข้อมูลสั้น ๆ รวมกันประมาณ 20 รายการ สำหรับผู้ช่วยส่วนตัวที่ควรจะ "เติบโตไปพร้อมกับคุณ" การชนเพดานนี้เกิดขึ้นเร็วจนน่าหงุดหงิด คุณจะพบว่าเอเจนต์ใช้เวลาไปกับการรวมและแทนที่ข้อมูลใน memory แทนที่จะทำงานจริง แนวทางที่มีขอบเขตจำกัดนั้นดีในเชิงปรัชญา แต่ในทางปฏิบัติมันหมายความว่าเอเจนต์จะลืมสิ่งที่คุณอยากให้มันจำ

2. Frozen Snapshot ทำให้เกิด 'Memory Lag'

การเปลี่ยนแปลง memory ระหว่าง session จะมีผลใน session ถัดไปเท่านั้น นี่หมายความว่าถ้าคุณบอกเอเจนต์ว่า "จำไว้นะว่าฉันเปลี่ยนไปใช้ PostgreSQL 17 แล้ว" มันจะเขียนลงดิสก์ — แต่ถ้าคุณถามเกี่ยวกับการตั้งค่าฐานข้อมูลของคุณในภายหลังในการสนทนาเดียวกัน system prompt จะยังคงแสดงข้อมูลเก่าอยู่ เอเจนต์ สามารถ ตรวจสอบสถานะปัจจุบันผ่านการตอบกลับของเครื่องมือได้ แต่มันก็ไม่ได้คิดจะทำอย่างนั้นเสมอไป สิ่งนี้นำไปสู่ช่วงเวลาที่สับสนซึ่งดูเหมือนว่าเอเจนต์ลืมสิ่งที่คุณเพิ่งบอกไป

3. Prompt ของ Cron ต้องสมบูรณ์ในตัวเอง

ทุก ๆ cron job จะรันใน session ที่ว่างเปล่า ไม่มี memory, ไม่มีประวัติการสนทนา, ไม่มี context จากการรันครั้งก่อน ๆ นี่หมายความว่า cron prompt ของคุณต้องอธิบาย ทุกอย่าง — ต้องทำอะไร, ทำอย่างไร, ใช้รูปแบบ output แบบไหน, ส่งไปที่ไหน การเขียน cron prompt ที่ดีเป็นทักษะอย่างหนึ่ง และความพยายามในช่วงแรก ๆ มักจะให้ผลลัพธ์ที่ไร้ประโยชน์เพราะคนระบุรายละเอียดไม่เพียงพอ

4. ข้อกำหนด Context ขั้นต่ำ 64K ทำให้รันโมเดล Local เล็ก ๆ ไม่ได้

ถ้าคุณอยากรันแบบ local เต็มรูปแบบด้วยโมเดล 7B หรือ 13B คุณอาจจะโชคไม่ดีนัก เว้นแต่คุณจะมี RAM พอสำหรับ context 64K นี่เป็นการตัดสินใจทางวิศวกรรมที่สมเหตุสมผล (context เล็ก = agent loop พัง) แต่มันหมายความว่า Hermes ไม่ได้ "รันได้บนทุกอย่าง" จริง ๆ — มันรันบนอะไรก็ได้ที่สามารถ serve โมเดลที่มี context 64K ได้

5. การรีสตาร์ท Gateway ทำให้การเชื่อมต่อหลุด

ถ้าคุณต้องรีสตาร์ท gateway (เพื่ออัปเดต, เปลี่ยน config, กู้คืนจาก crash) ทุก session ของ messaging ที่ใช้งานอยู่จะหลุดการเชื่อมต่อ ไม่มีการส่งต่ออย่างราบรื่น ผู้ใช้บน Telegram/Discord จะเห็นแค่ว่าบอทเงียบไป แล้วก็กลับมา สำหรับการใช้งานส่วนตัวนี่ก็โอเค แต่สำหรับการใช้งานในทีม นี่เป็นจุดที่ยังไม่ค่อยราบรื่นนัก

Hermes เหมาะกับงานแบบไหน: 3 การเปรียบเทียบสั้น ๆ

นี่ไม่ใช่การรีวิวฉบับเต็ม — เป็นแค่ข้อสังเกตเพื่อบอกตำแหน่งของมัน เพื่อให้คุณรู้ว่าควรจะเลือกใช้อะไรเมื่อไหร่

Hermes vs OpenClaw: ทั้งคู่เป็น personal AI agent ที่ self-host ได้ มี messaging gateway, cron, memory, และการใช้เครื่องมือ OpenClaw เป็น Node.js-based เน้นความหลากหลายของช่องทางและสถาปัตยกรรมแบบ plugin ส่วน Hermes เป็น Python-based เน้นที่ learning loop (skills, การพัฒนาตัวเอง) และความพร้อมสำหรับงานวิจัย (การ export trajectory, การเทรน RL) ถ้าคุณต้องการ "agent intelligence ที่เติบโตได้" ให้เลือก Hermes ถ้าคุณต้องการ "การส่งต่อข้อความที่เสถียรข้าม 15 แพลตฟอร์มพร้อม ecosystem ของ plugin ที่กว้างขวาง" ให้เลือก OpenClaw

Hermes vs LangGraph: LangGraph เป็น framework สำหรับสร้าง agent workflow — คุณเขียน graph, กำหนด node, จัดการ state ส่วน Hermes เป็นเอเจนต์ที่พร้อมใช้งาน — ติดตั้งแล้วก็คุยได้เลย ถ้าคุณต้องการการประสานงานของ multi-agent แบบ custom สำหรับผลิตภัณฑ์ ให้ใช้ LangGraph ถ้าคุณต้องการผู้ช่วยส่วนตัวที่ทำงานได้ทันทีหลังแกะกล่อง ให้ใช้ Hermes

Hermes vs CrewAI: CrewAI เน้นการสวมบทบาทของ multi-agent (เอเจนต์ "นักวิจัย", "นักเขียน", "บรรณาธิการ" ทำงานร่วมกัน) ส่วน Hermes เป็นเอเจนต์ตัวเดียวที่สามารถมอบหมายงานให้ subagent ได้ CrewAI เหมาะกว่าสำหรับ workflow ของทีมที่กำหนดไว้ล่วงหน้า Hermes เหมาะกว่าสำหรับงานช่วยเหลือส่วนตัวที่เปิดกว้าง ซึ่งไม่รู้ล่วงหน้าว่างานคืออะไร

Cheat Sheet สำหรับอ้างอิงเร็ว ๆ

คำสั่งที่จำเป็น

hermes                    # เริ่มคุย
hermes model              # เปลี่ยนผู้ให้บริการ LLM
hermes tools              # เปิด/ปิดชุดเครื่องมือ
hermes gateway setup      # ตั้งค่าแพลตฟอร์ม messaging
hermes gateway            # เริ่ม messaging gateway
hermes cron list          # ดูรายการ job ที่ตั้งเวลาไว้
hermes config set KEY VAL # ตั้งค่า config
hermes doctor             # ตรวจสอบปัญหา
hermes update             # อัปเดตเป็นเวอร์ชันล่าสุด
hermes --continue         # กลับไปทำ session ล่าสุดต่อ
hermes --yolo             # ข้ามการอนุมัติคำสั่ง (ระวัง!)

Config ที่แนะนำสำหรับการตั้งค่าครั้งแรก

# ~/.hermes/config.yaml

# ใช้ Docker เพื่อความปลอดภัย
terminal:
  backend: docker
  docker_image: python:3.11-slim
  container_persistent: true

# เปิดการอนุมัติคำสั่งไว้
approvals:
  mode: manual
  timeout: 60

ปัญหาที่เจอบ่อย ๆ

ปัญหา	สาเหตุ	วิธีแก้
เอเจนต์ไม่สนใจ memory ที่เพิ่งเพิ่มเข้าไป	Frozen snapshot — memory จะโหลดตอนเริ่ม session เท่านั้น	เริ่ม session ใหม่ (`hermes`)
Cron job ให้ผลลัพธ์มั่ว ๆ	Prompt ไม่สมบูรณ์ในตัวเอง	อธิบายทุกอย่างลงใน cron prompt
บอทไม่เห็นข้อความในกลุ่ม	Telegram privacy mode	ปิดใน BotFather แล้วเพิ่มบอทเข้ากลุ่มใหม่
โมเดลถูกปฏิเสธตอนเริ่มต้น	Context window < 64K	ใช้โมเดลที่ใหญ่ขึ้น หรือเพิ่ม `--ctx-size`
`hermes: command not found` หลังติดตั้ง	ยังไม่ได้รีโหลด Shell	รัน `source ~/.bashrc`

สรุป

Hermes Agent คือ open-source personal AI agent ที่สมบูรณ์ที่สุดที่มีในเดือนเมษายน 2026 learning loop (memory + skills + user modeling) เป็นสิ่งที่ใหม่จริง ๆ — เอเจนต์คู่แข่งส่วนใหญ่ไม่ได้พยายามทำการปรับปรุงข้าม session ด้วยซ้ำ terminal backends ทั้ง 6 แบบให้ความยืดหยุ่นในการใช้งานจริง ecosystem ที่มี 647 skills หมายความว่าคุณไม่ต้องเริ่มจากศูนย์

ข้อแลกเปลี่ยนก็มีอยู่จริง: ขีดจำกัด memory ที่เล็ก, lag จาก frozen snapshot, overhead ของ cron prompt, และข้อกำหนด context ขั้นต่ำ 64K แต่สิ่งเหล่านี้เป็นการตัดสินใจทางวิศวกรรม ไม่ใช่บั๊ก — มันช่วยให้ระบบมีขอบเขตและคาดเดาได้

ถ้าคุณต้องการ AI agent ที่อยู่บนเซิร์ฟเวอร์ของคุณ, คุยกับคุณจาก Telegram, รันงานตามกำหนดเวลา, และเก่งขึ้นเรื่อย ๆ เมื่อเวลาผ่านไป — Hermes คือตัวที่คุณต้องลอง การติดตั้งใช้เวลา 60 วินาที คุณจะรู้ได้ภายในหนึ่งชั่วโมงว่ามันเหมาะกับ workflow ของคุณหรือไม่

Links:

GitHub: github.com/NousResearch/hermes-agent
Docs: hermes-agent.nousresearch.com/docs
Discord: discord.gg/NousResearch
Skills Hub: agentskills.io
License: MIT

Hermes Agent Review 2026: AI Agent ที่พัฒนาตัวเองและจำคุณได้จริงๆ