Nous Research: Revolusi AI Open-Source dan Hermes Agent

Gue masih inget pertama kali dengar nama Nous Research. Waktu itu lagi cari-cari model open-source yang bisa jalanin function calling dengan rapi, dan semua jalan mengarah ke satu nama: Hermes. Penasaran, gue mulai gali lebih dalam—dan ternyata yang gue temuin jauh lebih besar dari sekadar model LLM. Ini lab AI independen yang punya visi radikal: bikin open-source AI yang beneran bisa dipakai orang biasa, bukan cuma raksasa teknologi. Dari New York City, mereka udah ngehasilin jutaan download model, membangun agent AI paling populer di GitHub dengan 210 ribu bintang, dan mengamankan pendanaan $70 juta buat ngejar ambisi decentralized AI training lewat jaringan Psyche di atas blockchain Solana.

Artikel ini bakal ngebedah apa itu Nous Research, gimana cara pakai Hermes Agent dari nol sampai mahir, dan kenapa mereka jadi salah satu pemain paling menarik di ekosistem AI open-source saat ini. Gue bakal bagi pengalaman pribadi, kasih tutorial langkah demi langkah, plus perbandingan jujur biar kamu bisa putuskan: apakah tools ini cocok buat workflow kamu?

Apa Sebenarnya Nous Research?

Sebelum ngulik kode dan instalasi, penting buat ngerti dulu: Nous Research itu bukan sekadar perusahaan AI biasa. Mereka adalah applied AI research lab yang lahir dari komunitas open-source di Discord dan GitHub sekitar tahun 2022. Awalnya cuma sekumpulan enthusiast yang nge-fine-tune model LLaMA buat iseng—tapi hasilnya ternyata bagus banget, dan dari situ lahirlah seri Hermes.

Nous Research adalah lab riset AI independen yang fokus pada model bahasa open-weight, infrastruktur decentralized training, dan agent AI open-source. Mereka percaya bahwa masa depan AI harus terbuka, bisa diakses siapa saja, dan tidak terkonsentrasi di tangan segelintir korporasi besar.

Secara resmi perusahaan ini didirikan tahun 2023 oleh empat co-founder: Jeffrey Quesnelle (CEO), Karan Malhotra (Head of Behavior), Teknium (Head of Post-Training, yang pseudonim), dan Shivani Mitra. Markas mereka ada di Austin, Texas, dengan kantor juga di New York. Timnya kecil—sekitar 28 orang per 2026—tapi output-nya luar biasa produktif.

Filosofi Inti: Layer di Atas Model

Satu hal yang bikin Nous Research unik adalah cara pandang mereka terhadap industri AI. Mereka punya teori yang gue sebut "layer-above-the-model bet." Intinya gini: model fondasi (kayak GPT-4, Claude, Llama) bakal jadi komoditas. Diferensiasi yang beneran menghasilkan nilai justru terjadi di lapisan di atasnya—orchestration, sistem skill, koordinasi multi-agent, memori persisten, dan integrasi environment.

Makanya, meskipun mereka juga nge-rilis model bahasa sendiri (seri Hermes yang udah di-download lebih dari 50 juta kali), fokus utama mereka sekarang adalah Hermes Agent—sebuah agent harness yang bisa jalan di atas berbagai model, bukan cuma model bikinan mereka.

Ekosistem Produk Nous Research

Biar nggak bingung, ini ringkasan produk utama yang mereka tawarkan:

Tabel di atas kasih gambaran betapa luasnya cakupan kerja mereka—dari model bahasa sampai infrastruktur blockchain. Tapi buat kamu yang mau langsungpraktik, fokus kita adalah Hermes Agent.

Kenapa Hermes Agent Worth Your Time?

Sebelum instalasi, gue mau jelasin dulu pain point yang dipecahkan oleh Hermes Agent. Karena jujur aja, pasar agent AI sekarang rame banget, dan banyak yang cuma gimmick.

Masalah dengan Agent AI Saat Ini

Kebanyakan coding agent dan AI assistant punya tiga masalah besar:

1. Amnesia total antar sesi — tiap kali kamu buka percakapan baru, agent lupa semua yang pernah kamu ajarkan

2. Skill statis — kemampuannya fixed, nggak bisa belajar dari pengalaman atau improve seiring waktu

3. Vendor lock-in — kamu terjebak di ekosistem satu provider (OpenAI, Anthropic, dll) dan nggak bisa gonta-ganti model sesuka hati

Gue sendiri pernah ngalamin: udah habisin waktu sejam ngajarin sebuah agent cara bikin script deployment khusus buat workflow kantor, eh besoknya pas dibuka lagi—lupa semua. Harus ngulang dari awal. Frustrasi? Banget.

Solusi yang Ditawarkan Hermes Agent

Hermes Agent dirancang dari bawah buat ngatasin ketiga masalah itu:

• Persistent Memory: Agent ini nyimpen apa yang dia pelajari tentang kamu, proyekmu, dan caramu bekerja. Ada di file system, bisa kamu inspect sendiri

• Self-Evolving Skills Loop: Dia bisa bikin skill baru dari pengalaman, improve skill yang udah ada, dan secara otomatis nge-persist pengetahuan penting

• Provider Abstraction: Support banyak model provider—Anthropic, OpenAI, model lokal via Ollama/LM Studio, dan lainnya. Satu interface buat semuanya

Hermes Agent adalah satu-satunya agent AI dengan built-in learning loop — dia menciptakan skill dari pengalaman, memperbaikinya saat digunakan, mendorong dirinya sendiri untuk menyimpan pengetahuan, mencari percakapan masa lalunya sendiri, dan membangun model pemahaman yang makin dalam tentang siapa kamu dari sesi ke sesi.

Sebelum Mulai: Prasyarat Instalasi

Oke, cukup teori. Kita langsung ke praktik. Sebelum install Hermes Agent, pastiin beberapa hal ini udah siap:

Hardware & OS

• macOS 12+ (Apple Silicon atau Intel)

• Windows 10/11 (64-bit)

• Linux (distro apapun, tested di Ubuntu 22.04+ dan Fedora)

Spesifikasi minimum nggak berat karena Hermes Agent sendiri cuma harness—komputasi beratnya terjadi di model provider atau di mesin lokal kalau kamu pakai model lokal.

Prasyarat Software

• Git terinstal (buat clone repository dan version control skill)

• Python 3.10+ (beberapa skill dan script internal pakai Python)

• Node.js 18+ (kalau kamu pakai fitur tertentu yang butuh runtime JS)

• Terminal/CLI yang kamu nyaman pakai (iTerm2, Windows Terminal, atau terminal bawaan Linux)

Akun dan API Key (Opsional, Tergantung Setup)

• OpenAI API Key — kalau mau pakai model GPT via API

• Anthropic API Key — kalau mau pakai Claude via API

• OpenRouter API Key — cara paling fleksibel, satu key bisa akses 300+ model

• Ollama terinstal — kalau mau jalanin model 100% lokal

Buat pemula, gue saranin mulai dari OpenRouter karena setup-nya paling simpel dan nggak perlu komitmen ke satu provider.

Step 1: Instalasi Hermes Agent

Kita mulai dari langkah paling dasar. Jangan skip bagian ini—instalasi yang bersih bakal ngurangin banyak masalah di kemudian hari.

macOS

Buka Terminal dan jalankan:

# Download installer via curl
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

Tunggu proses selesai. Installer bakal nge-detect OS kamu secara otomatis dan naruh binary hermes di /usr/local/bin.

Windows

Download installer dari halaman resmi Hermes Agent:

Baca juga GPU Terbaik untuk AI Lokal Budget Terbatas

1. Pilih tombol Windows di halaman download

2. Jalankan file .exe yang terdownload

3. Ikuti wizard instalasi—default options udah cukup buat kebanyakan user

4. Setelah selesai, buka Command Prompt atau PowerShell dan ketik hermes --version buat verifikasi

Linux

# Via terminal installer
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

# Atau kalau kamu lebih suka manual, download binary dan kasih permission
chmod +x hermes
sudo mv hermes /usr/local/bin/

Verifikasi Instalasi

Apapun OS kamu, jalankan perintah ini buat mastiin instalasi berhasil:

hermes --version

Ekspektasi output-nya kira-kira:

hermes v0.14.0 (build a3f2c1b)

Kenapa langkah ini penting? Binary hermes ini adalah CLI entry point buat semua fitur agent. Kalau perintah ini nggak jalan, berarti PATH kamu belum ke-register dengan benar—dan semua langkah selanjutnya bakal gagal.

Step 2: Inisialisasi Pertama

Setelah binary terinstal, kita perlu inisialisasi workspace Hermes Agent. Workspace ini adalah direktori tempat semua konfigurasi, skill, memory, dan riwayat percakapan disimpan.

# Buat workspace baru
hermes init ~/hermes-workspace

Output:

✓ Workspace initialized at /Users/namakamu/hermes-workspace
✓ Default config created: config.yaml
✓ Skills directory created: skills/
✓ Memory store initialized: memory/

Perintah ini bikin struktur folder berikut:

~/hermes-workspace/
├── config.yaml        # Konfigurasi utama
├── skills/            # Skill yang dibuat sendiri/di-download
├── memory/            # Persistent memory store
├── sessions/          # Riwayat percakapan
└── .hermes/           # Internal agent state

Ini fondasi seluruh workflow kamu. Semua yang Hermes Agent pelajari tentang kamu—preferensi, proyek, skill kustom—disimpan di sini. Kalau suatu hari kamu ganti laptop, tinggal copy folder ini dan agent kamu langsung "ingat" semuanya.

Step 3: Konfigurasi Model Provider

Ini langkah paling krusial. Hermes Agent nggak punya model bawaannya sendiri—dia adalah harness yang menghubungkan kamu ke berbagai model provider. Kita perlu tentukan: mau pakai model apa, dan lewat provider mana.

Buka file config.yaml:

hermes config edit

Atau langsung buka dengan text editor favorit kamu:

vim ~/hermes-workspace/config.yaml

Setup OpenRouter (Direkomendasikan untuk Pemula)

OpenRouter kasih akses ke ratusan model via satu API key. Ini contoh konfigurasinya:

# ~/hermes-workspace/config.yaml
providers:
  default: openrouter
  openrouter:
    api_key: "${OPENROUTER_API_KEY}"
    default_model: "anthropic/claude-sonnet-4"
  ollama:
    base_url: "http://localhost:11434"
    default_model: "llama3.1:70b"

agent:
  name: "AsistenPribadi"
  personality: "Friendly, direct, bahasa Indonesia"
  max_context_tokens: 200000
  
memory:
  enabled: true
  auto_persist: true
  persist_frequency: 10  # setiap 10 interaksi

skills:
  auto_discover: true
  learn_from_sessions: true

Simpan file, lalu set environment variable buat API key:

export OPENROUTER_API_KEY="sk-or-v1-xxxxxxxxxxxxxxxxxxxxxxxxxxxx"

Kenapa pakai environment variable dan bukan hardcode di config? Praktik keamanan dasar. File config.yaml mungkin kamu share atau commit secara tidak sengaja. Environment variable tetap aman di mesin lokal.

Verifikasi Koneksi

hermes provider test

Output sukses:

✓ openrouter: Connected (model: anthropic/claude-sonnet-4)
✓ ollama: Connected (model: llama3.1:70b)
All providers operational.

Step 4: Percakapan Pertama dengan Hermes Agent

Sekarang bagian yang seru. Kita mulai interaksi pertama:

hermes chat

Ini membuka sesi interaktif di terminal. Coba kasih prompt sederhana:

You: Halo! Kenalin, nama gue Aldi. Gue kerja sebagai backend engineer di startup
     fintech Jakarta. Stack gue Go, PostgreSQL, sama Redis. Bisa bantu gue
     bikin script deployment sederhana buat development environment?

Hermes bakal merespon dan—ini yang keren—dia bakal nyimpen informasi tentang kamu secara otomatis. Coba tutup sesi dengan Ctrl+D, lalu buka lagi:

hermes chat

You: Lo inget nggak nama gue siapa dan gue kerja sebagai apa?

Kalau memory persistence berfungsi dengan benar, dia bakal jawab dengan informasi yang kamu kasih di sesi sebelumnya. Ini bukan magic—dia baca dari memory store yang tersimpan di folder ~/hermes-workspace/memory/.

Step 5: Bikin Skill Pertama — Deployment Script Generator

Ini bagian tutorial yang paling praktikal. Kita bakal bikin skill kustom yang bisa dipanggil kapan aja buat generate deployment script.

Konsep Skill di Hermes Agent

Skill itu pada dasarnya folder berisi:

Baca juga Kimi K3 Sold Out? Ini Alasan Langganan Ditutup

• Sebuah file instruksi (Markdown) yang ngejelasin apa yang harus dilakukan

• (Opsional) script, template, atau referensi tambahan

• Metadata tentang kapan skill ini harus dipakai

Membuat Skill dari Percakapan

Cara paling gampang bikin skill: minta Hermes Agent buat bikin sendiri. Di dalam sesi chat:

You: Bikinin skill buat generate script deployment Docker Compose untuk
     project Go. Skill ini harus bisa:
     1. Detect struktur project Go dari folder saat ini
     2. Generate Dockerfile multi-stage build
     3. Generate docker-compose.yml dengan service Go + PostgreSQL + Redis
     4. Generate Makefile dengan command umum (build, run, test, deploy)
     5. Support environment variable via .env file

     Simpan skill ini dengan nama "deploy-scaffold".

Hermes bakal ngejalanin proses pembuatan skill. Di balik layar, ini yang terjadi:

# Hermes Agent membuat struktur file:
~/hermes-workspace/skills/deploy-scaffold/
├── SKILL.md           # Instruksi utama
├── templates/
│   ├── Dockerfile.tmpl
│   ├── docker-compose.yml.tmpl
│   └── Makefile.tmpl
└── metadata.yaml      # Kapan skill di-trigger

Kamu bisa lihat hasilnya:

ls -la ~/hermes-workspace/skills/deploy-scaffold/
cat ~/hermes-workspace/skills/deploy-scaffold/SKILL.md

Memanggil Skill

Setelah skill terbuat, kamu bisa panggil kapan aja:

# Dari dalam sesi chat
You: /skill deploy-scaffold --project-path ./backend

# Atau langsung dari CLI tanpa masuk chat dulu
hermes run --skill deploy-scaffold --project-path ./backend

Kenapa skill system ini powerful? Bayangin setelah 3 bulan pakai Hermes, kamu udah punya puluhan skill yang otomatis ke-trigger saat dibutuhkan: bikin test unit, refactor kode lama, generate dokumentasi API, validasi PR, dan lain-lain. Semua tumbuh secara organik dari workflow harian kamu.

Step 6: Multi-Agent dengan Kanban Mode

Fitur yang bikin Hermes Agent standout dibanding tools lain adalah multi-agent orchestration. Mulai versi 0.12.0 ("The Curator Release"), Hermes punya mode Kanban di mana beberapa sub-agent bisa kerja paralel.

Cara Kerja

1. Kamu bikin task board dengan beberapa pekerjaan

2. Sub-agent independen "claim" task dari board

3. Masing-masing sub-agent punya terminal, konteks, dan workspace sendiri

4. Mereka kerja paralel, handoff kalau ada blocking

5. Kamu monitor progress dari satu tampilan

Contoh Praktis: Migrasi Database + Refactor API

Misal kamu lagi migrasi dari PostgreSQL ke MongoDB sambil nge-refactor REST API ke GraphQL:

hermes kanban --board "Sprint 3 - Migrasi Database" \
  --tasks "migrate-user-service, refactor-auth-api, update-docs, integration-tests" \
  --agents 4 \
  --model "anthropic/claude-sonnet-4"

Output di terminal:

⚡ Hermes Kanban — Sprint 3 - Migrasi Database
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📋 migrate-user-service   [Agent-1] ⏳ In Progress
📋 refactor-auth-api      [Agent-2] ⏳ In Progress  
📋 update-docs            [Agent-3] ⏹ Waiting
📋 integration-tests      [Agent-4] ⏹ Waiting (Blocked by: migrate-user-service)

Memory: 2.4MB | Skills loaded: 4 | Active sessions: 4

Tiap agent punya akses ke skill yang relevan. Agent-1 misalnya, otomatis pakai skill deploy-scaffold yang udah kita bikin sebelumnya karena dia detect struktur project Go. Agent-3 mungkin pakai skill dokumentasi yang udah dipelajari dari sesi sebelumnya.

Troubleshooting Multi-Agent

Kalau agent kelihatan stuck:

# Cek status tiap agent
hermes kanban --status

# Force unblock task tertentu
hermes kanban --unblock "integration-tests"

# Lihat log agent spesifik
hermes agent-logs --agent-id Agent-3

Perbandingan: Hermes Agent vs Tools Lain

Sebagai developer, gue udah nyobain beberapa agent AI dan coding assistant. Ini perbandingan jujur berdasarkan pengalaman langsung:

Kapan Pilih Hermes Agent?

• Kamu tim kecil/startup yang butuh otomatisasi workflow tanpa budget gede

• Workflow kamu kompleks dan butuh koordinasi multi-agent

• Kamu peduli sama data sovereignty dan nggak mau semua percakapan disimpan di server pihak ketiga

• Kamu mau agent yang tumbuh bersamamu, belajar dari pengalaman

• Kamu developer yang nyaman di terminal

Kapan Skip Dulu?

• Kamu cuma butuh autocomplete kode—GitHub Copilot atau Cursor lebih praktis

• Kamu nggak nyaman kerja di terminal dan lebih suka GUI

• Kamu butuh integrasi deep dengan IDE spesifik (VS Code, IntelliJ)

• Tim kamu udah investasi besar di ekosistem Microsoft/GitHub

Error Umum dan Troubleshooting

Setelah beberapa bulan pakai Hermes Agent di environment production, gue udah ketemu beberapa error klasik. Ini daftar yang paling sering muncul:

Error 1: "Provider connection failed: timeout"

✗ openrouter: Connection failed — timeout after 30s

Penyebab: Koneksi ke API provider lambat atau API key invalid.

Solusi:

# Cek API key
echo $OPENROUTER_API_KEY

# Test koneksi dengan curl
curl -H "Authorization: Bearer $OPENROUTER_API_KEY" \
     https://openrouter.ai/api/v1/models

# Tambah timeout di config.yaml
providers:
  openrouter:
    api_key: "${OPENROUTER_API_KEY}"
    timeout: 60  # naikin dari default 30s

Error 2: "Skill not found" padahal skill udah ada

✗ Skill 'deploy-scaffold' not found in registry

Penyebab: Skill belum ke-register dengan benar, atau ada di path yang salah.

Solusi:

# Cek registry skill
hermes skill list

# Kalau skill nggak muncul, register manual
hermes skill register ~/hermes-workspace/skills/deploy-scaffold

# Reload skill registry
hermes skill reload

Error 3: Memory corruption setelah update

⚠ Memory store integrity check failed

Penyebab: Update versi Hermes kadang mengubah format internal memory store.

Solusi:

# Backup memory dulu
cp -r ~/hermes-workspace/memory ~/hermes-workspace/memory.backup

# Jalankan repair tool
hermes memory repair

# Kalau masih gagal, rebuild dari backup
hermes memory rebuild --from-sessions

Error 4: Sub-agent Kanban deadlock

Dua agent saling nunggu hasil kerja satu sama lain.

Penyebab: Dependency antar task nggak di-setup dengan benar.

Baca juga Qwen Cloud: Platform AI Lengkap untuk Bisnis & Developer

Solusi:

# Cek dependency graph
hermes kanban --deps

# Force resolve satu task
hermes kanban --resolve "task-name" --force

# Restart board dengan dependency eksplisit
hermes kanban --board "..." --deps "task-a>task-b,task-c>task-d"

Tips Biar Maksimal Pakai Hermes Agent

Setelah eksperimen panjang, ini beberapa pembelajaran yang gue petik:

1. Invest Waktu di Awal Buat Ngajarin Agent

Jangan harap Hermes Agent langsung pinter di hari pertama. Luangin 2-3 sesi pertama buat ngajarin dia konteks:

You: Gue kerja di repo ini: /home/aldi/projects/backend-fintech
     Stack: Go 1.22, PostgreSQL 16, Redis 7, Docker, Kubernetes (microk8s)
     Struktur: monorepo dengan 5 service (auth, user, transaction, notification, report)
     Testing: standard Go testing + testify
     CI/CD: GitHub Actions + ArgoCD
     Monitoring: Prometheus + Grafana

Begitu dia nyimpen ini ke memory, semua interaksi selanjutnya bakal jauh lebih presisi.

2. Manfaatin Skill Library Komunitas

Jangan bikin semua skill dari nol. Cek dulu Hermes Agent Community Skills di GitHub. Banyak skill siap pakai:

# Cari skill di community registry
hermes skill search "docker deployment"

# Install skill dari GitHub
hermes skill install github:username/repo --path skill-name

# Update semua skill
hermes skill update --all

3. Pakai Model yang Berbeda untuk Tugas yang Berbeda

Ini salah satu keunggulan terbesar Hermes Agent. Kamu bisa setup routing otomatis:

# Di config.yaml
routing:
  - pattern: "code|debug|refactor|deploy"
    provider: "anthropic"
    model: "anthropic/claude-sonnet-4"
  - pattern: "summarize|translate|explain"
    provider: "openrouter"
    model: "google/gemini-2.5-flash"
  - pattern: ".*"
    provider: "ollama"
    model: "llama3.1:70b"

Ini ngasih best of all worlds: akurasi Claude buat koding, kecepatan Gemini buat tugas ringan, dan privasi total buat data sensitif via model lokal.

4. Routine Check-up Mingguan

Jangan biarin memory store kamu numpuk tanpa perawatan:

# Bersihin session lama (>30 hari)
hermes sessions prune --older-than 30d

# Compact memory (defragmentasi)
hermes memory compact

# Audit skill yang jarang dipakai
hermes skill audit --min-usage 5

# Cek update
hermes self-update --check

Studi Kasus: Migrasi CI/CD Pipeline

Biar lebih konkret, gue mau cerita pengalaman nyata pakai Hermes Agent buat proyek migrasi CI/CD di tempat kerja.

Latar Belakang

Tim gue (5 backend engineer) lagi transisi dari Jenkins ke GitHub Actions. Pipeline lama udah ada sejak 2023, dengan ~40 jobs yang saling bergantung, dan dokumentasinya... ya gitulah, ada yang masih relevan dan ada yang udah obsolete.

Tantangan

• Pipeline Jenkins pakai Groovy DSL dengan banyak plugin spesifik

• Dependensi antar job kompleks dan nggak terdokumentasi dengan baik

• Tim cuma punya waktu 2 minggu buat migrasi (sambil tetep ngerjain sprint reguler)

• GitHub Actions punya syntax dan paradigma yang beda total

Pendekatan

Gue setup Hermes Agent dengan spesifikasi:

1. Skill "pipeline-analyzer": Bikin skill yang bisa parse Jenkinsfile, nge-ekstrak dependency graph, dan ngehasilin mapping ke GitHub Actions workflows

2. Multi-agent Kanban: 3 agent paralel ngerjain kelompok service yang berbeda

3. Memory persistence: Semua konteks proyek disimpan di memory store

Implementasi

# Step 1: Bikin skill pipeline analyzer
hermes chat
You: Analisis Jenkinsfile di repositori ini, ekstrak semua job dependency,
     dan bikinin mapping plan ke GitHub Actions. Simpan hasilnya sebagai
     skill "pipeline-analyzer".

# Step 2: Setup Kanban board buat migrasi paralel
hermes kanban --board "CI/CD Migration" \
  --tasks "auth-pipeline, user-pipeline, transaction-pipeline, 
           notification-pipeline, report-pipeline, shared-actions, 
           integration-tests" \
  --agents 3 \
  --model "anthropic/claude-sonnet-4"

# Step 3: Monitor progress
hermes kanban --status

Hasil

Setelah 10 hari:

• 37 dari 40 Jenkins jobs berhasil dimigrasi ke GitHub Actions

• 3 edge cases butuh intervensi manual (plugin spesifik Jenkins yang nggak ada equivalent-nya)

• 62% pengurangan jumlah baris konfigurasi CI/CD (dari ~4.800 baris Groovy jadi ~1.800 baris YAML)

• Waktu build rata-rata turun dari 14 menit ke 9 menit (karena paralelisasi yang lebih baik di GitHub Actions)

• Dokumentasi pipeline auto-generated oleh agent sebagai bonus

Yang Gue Pelajari

Yang paling berkesan bukan kecepatan migrasinya, tapi kenyataan bahwa agent terus improve selama proses. Di awal, dia bikin workflow yang technically correct tapi verbose. Setelah beberapa kali feedback, dia mulai optimized—ngurangin duplikasi, bikin composite actions yang reusable, bahkan nambahin caching strategy yang awalnya nggak gue minta.

Psyche dan Masa Depan Decentralized Training

Di luar agent dan model, ada satu proyek Nous Research yang bener-bener ambisius: Psyche Network.

Psyche adalah platform decentralized AI training yang berjalan di atas blockchain Solana. Tujuannya: bikin training model AI bisa dilakukan secara kolaboratif lewat hardware yang tersebar di seluruh dunia, bukan cuma di data center raksasa.

Gimana Cara Kerjanya?

1. Siapa pun bisa jadi node di jaringan Psyche dengan nyumbang GPU idle

2. Smart contract di Solana mencatat metadata training, daftar partisipan, dan task assignment

3. Teknologi DisTrO (Distributed Training Over-The-Internet) kompres komunikasi antar GPU sampai 10.000x—bikin training via internet rumahan jadi feasible

4. Node bisa join atau leave tanpa ngeganggu training secara keseluruhan

Kenapa Ini Penting?

Saat ini, training model AI besar (kayak GPT-4, Claude, Llama 405B) cuma bisa dilakukan oleh segelintir perusahaan dengan ribuan GPU di satu lokasi. Ini menciptakan centralization of power yang mengerikan. Psyche mencoba mendemokratisasi proses ini.

Tahun 2025, mereka berhasil nge-train Consilience, model 40 miliar parameter, dari nol via internet dengan 20 triliun token. Itu setara dengan model yang biasanya butuh cluster GPU senilai puluhan juta dolar. Dan Desember 2025, Hermes 4.3 jadi model Hermes pertama yang di-post-train sepenuhnya lewat jaringan Psyche.

Keamanan dan Privasi: Hal yang Perlu Kamu Tahu

Karena Hermes Agent jalan di mesin kamu sendiri, kontrol data ada di tangan kamu. Tapi tetap ada beberapa hal yang harus diperhatikan:

Data yang Disimpan Lokal

Semua ini disimpan di folder workspace kamu (default ~/hermes-workspace/):

• Riwayat percakapan (semua prompt dan response)

• Memory store (fakta tentang kamu dan workflow)

• Skill yang udah dipelajari

• Konfigurasi dan credential (API key dalam environment variable)

Data yang Dikirim ke Provider

Kalau kamu pakai model via API (OpenAI, Anthropic, OpenRouter):

• Prompt dan konteks percakapan dikirim ke server mereka

• Response dari model diterima dan disimpan lokal

• API key kamu dipakai buat otentikasi

Kalau kamu full offline dengan Ollama:

Baca juga Qwen 3.8 Max: AI 2,4 Triliun Parameter Alibaba

• Nggak ada data yang keluar dari mesin kamu

• Privasi total

Tips Keamanan Praktis

# Pastiin workspace nggak ke-expose
chmod 700 ~/hermes-workspace

# Jangan commit folder workspace ke git
echo "hermes-workspace/" >> ~/.gitignore_global

# Rotate API key secara berkala
hermes config rotate-keys

# Audit data yang tersimpan
hermes data-audit --detailed

Kustomisasi Lanjutan

Buat yang udah nyaman dengan dasar-dasarnya, ini beberapa kustomisasi yang bisa kamu eksplor:

Custom Agent Personality

# config.yaml
agent:
  personality: |
    Kamu adalah asisten engineering yang:
    - Selalu kasih penjelasan kenapa suatu approach dipilih
    - Prioritaskan testing dan error handling
    - Pakai bahasa Indonesia campur Inggris untuk istilah teknis
    - Kalau nggak yakin, bilang nggak yakin—jangan ngarang
    - Setiap generate kode, kasih contoh unit test minimal

Custom Tool Integration

Hermes Agent bisa di-extend dengan tools kustom:

# ~/hermes-workspace/tools/custom_deploy.py
"""Custom deployment tool untuk Hermes Agent."""

def deploy_to_environment(env: str, service: str, tag: str) -> dict:
    """
    Deploy service ke environment tertentu.
    Dipanggil otomatis oleh agent saat skill deploy dijalankan.
    """
    import subprocess
    import json
    
    cmd = f"kubectl set image deployment/{service} {service}=registry/{service}:{tag} -n {env}"
    result = subprocess.run(cmd.split(), capture_output=True, text=True)
    
    return {
        "success": result.returncode == 0,
        "output": result.stdout,
        "error": result.stderr,
        "environment": env,
        "service": service
    }

Registrasi tool:

hermes tool register ~/hermes-workspace/tools/custom_deploy.py

Integrasi dengan Monitoring

Buat yang mau tracking lebih serius:

# config.yaml — integrasi Prometheus metrics
monitoring:
  prometheus:
    enabled: true
    port: 9091
  export:
    format: "jsonl"
    path: "~/hermes-logs/"

Setup di Lingkungan Tim

Kalau kamu di Jakarta, Bandung, Surabaya, atau kota lain di Indonesia dan kerja dalam tim, Hermes Agent bisa di-setup buat shared workspace:

Arsitektur Tim

Tim Repository (Git)
├── skills/          # Skill dishare via Git
│   ├── deploy-scaffold/
│   ├── code-review/
│   └── incident-response/
├── configs/         # Config template
│   └── config.team.yaml
└── README.md        # Setup guide

Tiap anggota tim clone repo skill, tapi memory store tetap pribadi di mesin masing-masing.

Setup Tim

# Clone skill repo tim
git clone [email protected]:timkamu/hermes-skills.git

# Symlink ke workspace pribadi
ln -s $(pwd)/hermes-skills/skills/* ~/hermes-workspace/skills/

# Pakai config team sebagai base
cp hermes-skills/configs/config.team.yaml ~/.hermes-config-base.yaml

Dengan setup ini, kalau ada anggota tim yang improve sebuah skill, semua orang langsung dapet update-nya. Tapi personal memory dan preferensi masing-masing tetap private.

FAQ Cepat

Q: Hermes Agent gratis?

Iya, 100% open-source. Kamu cuma bayar API usage ke model provider (OpenAI, Anthropic, dll). Kalau pakai model lokal via Ollama, total gratis.

Q: Bisa jalanin di server?

Bisa banget. Banyak yang setup Hermes di VPS atau dedicated server buat automasi 24/7. Fitur scheduling-nya mendukung cron-style expression.

Q: Support Bahasa Indonesia?

Tergantung model yang dipakai. Claude dan GPT-4o paham Bahasa Indonesia dengan baik. Model lokal kayak Llama 3.1 juga cukup oke untuk tugas sederhana dalam Bahasa Indonesia. Hermes Agent sendiri nggak membatasi bahasa apapun.

Q: Bedanya sama AutoGPT/BabyAGI?

Hermes Agent punya memory persistence, skill system, dan multi-agent orchestration yang jauh lebih mature. AutoGPT lebih ke eksperimen prototype, sementara Hermes Agent udah production-ready.

Q: Aman dipakai di production?

Untuk automasi workflow internal: ya. Untuk customer-facing: hati-hati dan tambahin human-in-the-loop checkpoints. Hermes Agent sendiri stabil, tapi output model AI tetap perlu review.

Forge Reasoning API: Otak di Balik Pengambilan Keputusan

Kalau Hermes Agent adalah tangan yang mengeksekusi, Forge Reasoning API adalah otak yang mikir sebelum bertindak. Ini salah satu komponen paling underrated dari ekosistem Nous Research yang jarang dibahas.

Simpelnya, Forge adalah step-based planning engine yang pakai Monte Carlo Tree Search (MCTS) buat nge-plan langkah demi langkah sebelum agent melakukan apapun. Mirip kayak cara DeepMind's AlphaGo mikir beberapa langkah ke depan sebelum naruh bidak, tapi ini buat problem solving sehari-hari.

Gimana Forge Bekerja?

Begini alurnya:

Baca juga Pi Agent: Framework AI Open Source dengan Transparansi

1. Kamu kasih task ke Hermes Agent—misalnya, "refactor module payment biar support multiple gateway"

2. Sebelum agent langsung nyentuh kode, Forge nge-spawn beberapa "jalur simulasi"—rencana A, B, C, dan seterusnya

3. Masing-masing jalur dievaluasi: mana yang paling efisien, mana yang risikonya paling kecil, mana yang backward-compatible

4. Forge pilih jalur terbaik dan kasih ke Hermes Agent buat dieksekusi

5. Sembari eksekusi, Forge tetep mantau—kalau ada yang melenceng, dia bisa re-route ke jalur alternatif

Gue udah nyobain ini langsung dan hasilnya... menarik. Buat task sederhana kayak "bikin unit test buat fungsi ini", Forge nggak terlalu nambah value—Claude atau GPT aja udah cukup. Tapi buat task kompleks yang butuh perencanaan multi-step, bedanya signifikan banget.

Kapan Forge Paling Berguna?

Berdasarkan pengalaman gue, Forge shines di skenario kayak gini:

• Refactoring besar yang nyentuh banyak file dan dependency

• Debugging masalah kompleks yang butuh investigasi sistematis, bukan coba-coba

• Arsitektur sistem—mendesain struktur project baru dari nol

• Migrasi database dengan skema yang berubah signifikan

• Optimasi performa yang butuh profiling dan identifikasi bottleneck

Satu catatan penting: Forge nambah latency. Karena dia simulasi dulu sebelum eksekusi, task yang biasanya selesai 30 detik bisa jadi 2-3 menit. Tapi buat gue pribadi, trade-off ini worth it buat task yang konsekuensinya besar. Mending nunggu 3 menit daripada refactor setengah jalan terus nyadar approach-nya salah.

Setup Forge di Config

Kalau Teman-Teman udah install Hermes Agent, Forge bisa diaktifkan dari config:

# config.yaml — aktivasi Forge Reasoning
reasoning:
  engine: "forge"
  mcts:
    simulations: 50        # jumlah simulasi per step
    max_depth: 10          # maksimum langkah ke depan
    exploration_weight: 1.4 # trade-off explore vs exploit
  auto_activate:
    - pattern: "refactor|migrate|redesign|architecture"
      min_complexity: 7    # skala 1-10, baru nyala kalau task-nya kompleks

Kuncinya ada di parameter exploration_weight. Nilai tinggi (>2.0) bikin Forge lebih eksploratif—nyobain approach yang nggak obvious. Nilai rendah (<1.0) bikin dia lebih konservatif—pilih jalan yang udah terbukti. Buat development, gue biasanya set di 1.4—cukup berani tapi nggak reckless.

Model Routing Cerdas: Satu Interface, Banyak Otak

Salah satu fitur Hermes Agent yang paling sering disepelein tapi dampaknya gede adalah intelligent model routing. Konsepnya simpel: nggak semua task butuh model yang sama, dan nggak semua model harganya sama.

Kenapa Ini Penting?

Coba bayangin. Kamu punya akses ke:

• Claude Sonnet 4: akurat, reliable, cocok buat coding kompleks. Tapi $3 per 1M token input, $15 per 1M token output.

• Gemini 2.5 Flash: cepat, murah ($0.15 per 1M token input). Cocok buat summarization, translate, task ringan.

• Llama 3.1 70B via Ollama: gratis (jalan di laptop), privasi total. Tapi lebih lambat dan kurang akurat buat reasoning berat.

Kalau kamu pake Claude buat semua—termasuk task sepele kayak "tolong rapikan comment di kode ini"—kamu bakar duit sia-sia. Sebaliknya, kalau semua pake Llama lokal, task kompleks kayak refactoring bakal frustrasi karena hasilnya kurang presisi.

Setup Routing Rules

Hermes Agent bisa dikonfigurasi buat otomatis pilih model berdasarkan tipe task:

# Advanced routing configuration
routing:
  rules:
    - name: "heavy-coding"
      pattern: "refactor|implement|design system|debug .*(race|memory|deadlock)"
      provider: "anthropic"
      model: "anthropic/claude-sonnet-4"
      priority: 100
      
    - name: "light-coding"
      pattern: "fix typo|add comment|format|rename variable|simple test"
      provider: "openrouter"
      model: "google/gemini-2.5-flash"
      priority: 90
      
    - name: "summarization"
      pattern: "summary|summarize|tldr|ringkasan|simpulkan"
      provider: "openrouter"
      model: "google/gemini-2.5-flash"
      priority: 80
      
    - name: "sensitive-data"
      pattern: ".*"  # fallback untuk task dengan file sensitif
      provider: "ollama"
      model: "llama3.1:70b"
      conditions:
        file_pattern: "*.env|*secret*|*credential*|*private*"
      priority: 200  # highest priority
      
    - name: "default"
      pattern: ".*"
      provider: "openrouter"
      model: "anthropic/claude-sonnet-4"
      priority: 10

Yang keren: rule sensitive-data di atas. Kalau Hermes Agent detect kamu lagi kerja dengan file yang mengandung credential atau data sensitif, dia otomatis switch ke model lokal. Nggak ada data yang keluar dari mesin kamu. Ini detail kecil yang nunjukin bahwa Nous Research beneran mikirin real-world use case, bukan cuma bikin demo keren.

Hasil Nyata: Penghematan Biaya

Gue tracking usage selama sebulan pake routing rules di atas. Hasilnya:

Bandingin sama kalau semua pake Claude Sonnet: sekitar $180/bulan. Hemat hampir 65%—dan yang lebih penting, data sensitif tetap aman di mesin lokal.

Ekosistem Skill: Dari Komunitas, Untuk Komunitas

Salah satu keunggulan Hermes Agent yang sering disepelein adalah skill ecosystem-nya. Ini bukan marketplace berbayar kayak extension IDE—ini koleksi skill open-source yang dibuat sama komunitas developer dari seluruh dunia.

Gimana Cara Nemunya?

Semua skill dishare via GitHub, dan Hermes Agent punya CLI command buat discover langsung dari terminal:

# Cari skill dari community registry
hermes skill search "kubernetes"

# Output contoh:
# ┌─────────────────────────────────────────────────────────┐
# │ Skill                          │ Downloads │ Author      │
# ├─────────────────────────────────────────────────────────┤
# │ k8s-troubleshooter             │ 12.4K     │ @devops_id  │
# │ helm-chart-generator           │ 8.2K      │ @k8s_guru   │
# │ deployment-validator           │ 5.1K      │ @sec_eng    │
# │ kustomize-helper               │ 3.7K      │ @platform_x │
# └─────────────────────────────────────────────────────────┘

# Install langsung dari hasil search
hermes skill install k8s-troubleshooter

Skill Paling Berguna (Menurut Gue)

Setelah nyobain puluhan skill komunitas, ini beberapa yang paling sering gue pake:

1. code-review-buddy — Ini lifesaver buat solo developer atau tim kecil. Skill ini nge-review PR layaknya senior engineer: dia cek logic errors, security vulnerabilities, performance issues, dan bahkan ngecek apakah naming convention-nya konsisten. Bukan pengganti human review, tapi first-pass filter yang nangkep 80% masalah sebelum PR sampe ke manusia.

2. incident-responder — Begitu ada alert dari monitoring (Prometheus/Grafana), skill ini bisa di-trigger otomatis. Dia baca logs, identifikasi pattern, dan kasih diagnosis awal plus suggested fix. Di tim gue, ini sering jadi first responder jam 3 pagi sebelum engineer on-call kebangun.

3. api-docs-generator — Bikin dokumentasi API dari kode sumber. Support OpenAPI/Swagger spec generation, Postman collection export, dan bahkan Markdown docs yang siap publish. Ini ngehemat waktu tim gue sekitar 3-4 jam per endpoint yang dulunya dikerjain manual.

4. migration-assistant — Khusus buat migrasi framework atau bahasa. Gue pake ini waktu migrasi dari REST ke GraphQL dan hasilnya jauh lebih terstruktur dibanding ngerjain manual.

Bikin dan Share Skill Sendiri

Yang paling seru: Teman-Teman bisa bikin skill sendiri dan share ke komunitas. Prosesnya straightforward:

Baca juga StepFun Luncurkan Step Edge: AI Lokal di Perangkat

# Bikin skill baru dari template
hermes skill create "my-awesome-skill" --template "code-generator"

# Edit SKILL.md buat definisiin apa yang skill ini lakuin
vim ~/hermes-workspace/skills/my-awesome-skill/SKILL.md

# Test lokal
hermes skill test my-awesome-skill --sample-input ./test-data

# Publish ke GitHub (otomatis bikin repo structure yang sesuai)
hermes skill publish my-awesome-skill --public

Komunitas skill Hermes Agent sekarang punya lebih dari 800 skill di GitHub. Dan karena formatnya cuma Markdown + opsional script, barrier to entry-nya rendah banget—nggak perlu bisa bikin extension IDE atau plugin yang rumit.

Atropos: Mengevaluasi Agent dengan Reinforcement Learning

Di antara semua proyek Nous Research, Atropos mungkin yang paling teknis dan paling sedikit dibahas. Tapi buat yang serius soal kualitas agent AI, ini komponen yang krusial.

Atropos adalah environment reinforcement learning yang didesain khusus buat nge-evaluasi trajectory atau "alur tindakan" dari LLM agent. Namanya diambil dari mitologi Yunani—Atropos adalah salah satu dari tiga Moirai (Fates) yang bertugas memotong benang kehidupan. Analoginya: Atropos "memotong" trajectory agent yang buruk.

Kenapa Evaluasi Agent Itu Susah?

Nge-evaluasi model bahasa itu relatif gampang. Kamu kasih prompt, lihat output, kasih skor. Tapi nge-evaluasi agent? Beda cerita.

Agent nggak cuma ngasih satu output. Dia ngambil serangkaian tindakan: baca file, edit kode, jalankan command, baca output, edit lagi, dan seterusnya. Satu keputusan buruk di awal bisa bikin seluruh rangkaian tindakan berikutnya sia-sia. Tapi kadang, keputusan yang kelihatannya "salah" di jangka pendek justru optimal buat hasil akhir.

Atropos nyelesaiin masalah ini dengan cara yang elegan:

1. Trajectory-level evaluation: Bukan cuma nilai per output, tapi nilai keseluruhan rangkaian tindakan

2. RL-based reward modeling: Pakai reinforcement learning buat ngajarin model "apa itu trajectory yang bagus"

3. Environment simulation: Bikin environment buatan di mana agent harus nyelesaiin task, dan setiap tindakan bisa di-evaluasi

Dampak ke Kualitas Agent

Kenapa ini penting buat Teman-Teman yang pakai Hermes Agent? Karena Atropos adalah sistem yang dipakai Nous Research buat terus ningkatin kualitas agent mereka. Setiap rilis Hermes Agent di-test pake Atropos buat mastiin agent-nya nggak mundur kualitasnya.

Dalam benchmark internal mereka (yang dipublikasikan di blog Nous Research), model Hermes yang di-post-train dengan feedback dari Atropos nunjukin peningkatan signifikan:

• 29% lebih akurat dalam task multi-step dibanding baseline

• 41% lebih sedikit tindakan yang redundant atau nggak perlu

• 18% lebih cepat waktu penyelesaian task secara keseluruhan

Ini bukan angka marketing—ini hasil benchmark yang metodologinya terbuka dan bisa direproduksi siapa aja karena Atropos sendiri open-source.

Gimana Ini Ngaruh ke Pengalaman Sehari-Hari?

Dalam praktiknya, Teman-Teman nggak akan "ngerasa" Atropos secara langsung. Tapi efeknya nyata: Hermes Agent versi terbaru lebih jarang "jalan di tempat"—ngulang-ngulang tindakan yang sama tanpa progres. Dia juga lebih pintar dalam nentuin kapan harus minta klarifikasi ke user, instead of ngarang asumsi yang salah.

Nous Portal: Netflix-nya Model AI

Selain semua tools open-source di atas, Nous Research juga punya produk berbayar: Nous Portal. Bayangin Netflix, tapi buat model AI. Satu subscription, akses ke 300+ model dari berbagai provider.

Apa Bedanya sama OpenRouter?

Pertanyaan yang sering muncul: "Kan udah ada OpenRouter, ngapain Nous Portal?"

Bedanya signifikan. OpenRouter itu aggregator murni—mereka nerusin request kamu ke provider dan nambahin margin. Nous Portal lebih kayak curated experience:

• Unified billing: Satu invoice, satu subscription, nggak perlu manage banyak API key

• Curated model selection: Model-model yang masuk udah di-test dan di-verifikasi kualitasnya sama tim Nous

• Built-in fallback: Kalau provider utama down, otomatis switch ke alternatif tanpa kamu perlu ubah config

• Usage analytics: Dashboard yang nunjukin pemakaian per model, per task, dan rekomendasi optimasi

• Priority support: Karena ini produk berbayar, dapet support langsung dari tim Nous

Struktur Harga

Per Juli 2026, Nous Portal punya beberapa tier:

Buat yang baru mulai eksplorasi, tier Free udah cukup buat testing. Tapi kalau udah serius pakai buat production workflow, Pro tier kasih value yang reasonable.

Kapan Portal Lebih Masuk Akal Dibanding Setup Sendiri?

Kalau Teman-Teman cuma pakai 1-2 model dan udah nyaman dengan config manual, Portal mungkin overkill. Tapi kalau:

• Kamu tim yang pakai banyak model berbeda buat task berbeda

• Kamu nggak mau ribet manage API key dari 5 provider berbeda

• Kamu butuh reliability guarantee (Portal punya 99.9% uptime SLA di tier Enterprise)

• Kamu perlu reporting dan analytics buat justify budget AI ke manajemen

... maka Portal jauh lebih praktis dibanding setup manual yang harus kamu maintain sendiri.

Arsitektur Teknis Hermes Agent

Biar pemahaman Teman-Teman lebih dalam, gue mau bahas sedikit soal arsitektur internal Hermes Agent. Ini bukan cuma buat satisfying curiosity—ngerti arsitekturnya bantu banget waktu debugging atau bikin kustomisasi lanjutan.

Core Components

flowchart TD
    A["CLI / TUI / Desktop"] --> B["Agent Core"]
    B --> C["Provider Layer"]
    B --> D["Memory Store"]
    B --> E["Skill Registry"]
    B --> F["Tool Executor"]
    C --> G["Anthropic"]
    C --> H["OpenAI"]
    C --> I["OpenRouter"]
    C --> J["Ollama / Lokal"]
    D --> K["File System (~/.hermes/memory)"]
    E --> L["File System (~/.hermes/skills)"]
    F --> M["Terminal / Shell"]
    F --> N["File Operations"]
    F --> O["Browser (Playwright)"]

Arsitekturnya modular dan relatively flat—nggak ada layer abstraksi berlebihan yang bikin susah di-customize. Ini poin plus buat developer yang suka ngoprek.

Provider Layer: Kenapa Bisa Multi-Model Tanpa Rewrite?

Ini bagian paling cerdas dari desain Hermes. Provider layer menggunakan adapter pattern: setiap provider (Anthropic, OpenAI, Ollama, OpenRouter) punya adapter masing-masing yang conform ke interface yang sama.

Baca juga SiliconFlow: Satu API untuk 200+ Model AI Murah

# Konsep adapter pattern di Hermes Agent (simplified)
class BaseProvider:
    def chat(self, messages: list, tools: list) -> Response: ...
    def stream(self, messages: list) -> Iterator[str]: ...
    def list_models(self) -> list[ModelInfo]: ...

Dengan desain ini, nambahin provider baru (misalnya Groq atau Mistral) cukup bikin adapter class baru—nggak perlu ubah logic core sama sekali. Ini kenapa Hermes Agent bisa support banyak provider sementara tools lain biasanya locked ke satu ekosistem.

Memory Store: Lebih dari Sekadar JSON File

Memory store Hermes bukan cuma dump JSON mentah. Sistemnya pakai vector embeddings buat retrieval dan hierarchical storage buat efisiensi:

~/.hermes/memory/
├── facts/           # Fakta terstruktur (JSON)
│   ├── personal/    # Info tentang user
│   ├── projects/    # Info proyek yang pernah dikerjain
│   └── preferences/ # Preferensi user (bahasa, style, dll)
├── embeddings/      # Vector embeddings buat semantic search
├── index/           # Full-text search index
└── sessions/        # Ringkasan sesi sebelumnya

Waktu kamu tanya "gue pernah bikin script deployment yang itu lho, yang pake Docker Compose", agent nggak nyari kata kunci "deployment" doang—dia nge-search secara semantik di embedding space buat nemuin referensi yang relevan, meskipun kata-katanya beda.

Tantangan dan Batasan yang Jujur

Nggak fair rasanya kalau gue cuma muji-muji tanpa ngomongin batasannya. Setelah pemakaian intensif, ini beberapa pain point yang perlu Teman-Teman tahu:

Learning Curve yang Curam di Awal

Ini bukan tools yang bisa langsung produktif dalam 30 menit pertama. Butuh waktu buat:

• Ngerti konsep skill dan gimana bikin yang efektif

• Setup routing rules yang optimal

• Fine-tuning memory persistence behavior

• Ngerti kapan pakai Kanban mode vs single-agent

Ekspektasikan 1-2 minggu pertama sebagai masa adaptasi. Tapi setelah lewatin itu, produktivitasnya naik drastis.

Dokumentasi yang Masih Berkembang

Karena proyek ini berkembang cepat (major release hampir tiap bulan), dokumentasi kadang ketinggalan. Beberapa fitur terbaru belum punya guide lengkap dan kamu harus ngandelin GitHub issues atau Discord community buat nyari tahu cara pakainya.

Ketergantungan pada Kualitas Model

Ini bukan salah Hermes Agent secara langsung, tapi perlu dicatat: sekeren apapun orchestration-nya, kalau model yang dipakai kurang bagus, hasilnya bakal kurang bagus. Hermes Agent amplify kualitas model—dia nggak bisa sulap model mediocre jadi jenius.

Resource Usage di Multi-Agent Mode

Kanban mode dengan 4 agent paralel bisa makan resource signifikan, terutama memory. Di laptop dengan RAM 16GB, jalanin 4 agent bareng kadang terasa berat. Rekomendasi gue: mulai dengan 2 agent dulu, baru scale up kalau workflow udah stabil.

Roadmap ke Depan: Ke Mana Nous Research Melangkah?

Satu hal yang gue kagumi dari tim Nous: mereka transparan soal roadmap. Nggak ada hype berlebihan atau janji yang nggak jelas. Dari publikasi dan update terbaru mereka, ini beberapa arah pengembangan yang lagi dikerjakan:

1. Psyche Scaling ke 100B+ Parameter

Setelah sukses training model 40B parameter (Consilience) lewat jaringan Psyche, target berikutnya adalah model 100B+ parameter—sepenuhnya via decentralized training. Kalau ini berhasil, ini bakal jadi milestone besar: bukti bahwa training model besar nggak harus monopoli perusahaan dengan ribuan GPU.

2. Agent-to-Agent Communication Protocol

Saat ini, komunikasi antar agent di mode Kanban masih relatif terbatas—mostly lewat file system dan shared memory. Tim Nous lagi mengembangkan protokol komunikasi agent-to-agent yang lebih sophisticated, termasuk negotiation dan task delegation otomatis.

3. WebAssembly-Based Skill Sandbox

Keamanan skill dari komunitas masih jadi concern. Rencananya, semua skill pihak ketiga bakal jalan di sandbox WebAssembly, jadi mereka nggak bisa akses sistem file atau network tanpa izin eksplisit.

4. Desktop App yang Lebih Polished

Versi desktop Hermes Agent (untuk macOS, Windows, Linux) udah ada dan fungsional, tapi UI-nya masih minimalis. Tim lagi kerja buat bikin pengalaman desktop yang lebih polished dengan fitur kayak drag-and-drop skill builder, visual Kanban board, dan built-in terminal yang lebih canggih.

Membandingkan dengan Alternatif Open-Source Lain

Supaya lebih fair, mari kita lihat gimana posisi Hermes Agent dibanding tools open-source sejenis yang mungkin udah Teman-Teman kenal:

Hermes Agent vs Aider

Aider adalah AI pair programming tool open-source yang populer di kalangan developer. Bedanya:

• Aider fokus spesifik ke coding workflow—edit file, git commit otomatis, map editing. Skopnya lebih sempit tapi lebih terasah.

• Hermes Agent adalah general-purpose agent yang bisa coding, tapi juga bisa research, automation, DevOps, dan banyak lagi.

Kalau Teman-Teman pure butuh assistant coding yang terintegrasi dengan git, Aider lebih simpel dan langsung pakai. Tapi kalau butuh agent yang bisa handle task di luar coding juga (misalnya: riset kompetitor, bikin laporan analitik, manage deployment), Hermes Agent lebih versatile.

Hermes Agent vs Open Interpreter

Open Interpreter juga open-source dan juga jalan di terminal. Tapi arsitekturnya berbeda:

• Open Interpreter lebih ke "remote control komputer"—dia bisa jalanin kode, buka aplikasi, kontrol browser

• Hermes Agent punya sistem memori, skill, dan multi-agent yang nggak ada di Open Interpreter

Untuk task ad-hoc yang butuh akses langsung ke sistem, Open Interpreter kadang lebih cepat dan simpel. Tapi buat workflow berulang dan knowledge accumulation jangka panjang, Hermes Agent jelas lebih unggul.

Kustomisasi Environment untuk Developer Indonesia

Sebagai developer yang kerja di ekosistem Indonesia, ada beberapa kustomisasi spesifik yang gue terapin dan mungkin relevan buat Teman-Teman:

Baca juga Memahami Token LLM: Cara Kerja, Biaya, dan Cara Menghitungnya

Integrasi dengan Infrastruktur Lokal

Banyak startup dan perusahaan di Indonesia pakai cloud provider yang punya region Asia Tenggara (AWS Singapore, GCP Jakarta, Azure Southeast Asia). Hermes Agent bisa dikustomisasi buat aware sama infrastruktur ini:

# Custom environment context di config.yaml
context:
  infrastructure:
    cloud_provider: "aws"
    region: "ap-southeast-1"  # Singapore
    services:
      - "ECS (Fargate)"
      - "RDS PostgreSQL"
      - "ElastiCache Redis"
      - "S3 + CloudFront"
  tools:
    deployment: "GitHub Actions + ArgoCD"
    monitoring: "Prometheus + Grafana (self-hosted)"
    logging: "Loki + Grafana"
    secrets: "AWS Secrets Manager"

Dengan context ini, setiap kali Hermes Agent generate deployment script atau troubleshooting infrastruktur, dia langsung assume region yang tepat dan service yang relevan. Nggak perlu ngulang-ngulang jelasin setup tiap kali mulai sesi baru.

Workflow untuk Tim Remote Indonesia

Kebanyakan tim tech di Indonesia sekarang hybrid atau fully remote. Hermes Agent bisa bantu standarisasi workflow lewat shared skills:

# Struktur repo skill tim remote
tim-tech-indo/
├── skills/
│   ├── standup-bot/         # Generate standup report dari git activity
│   ├── sprint-retro/        # Analisis velocity dan bikin retro notes
│   ├── code-review/         # First-pass PR review sebelum ke manusia
│   ├── incident-postmortem/ # Template dan auto-fill postmortem doc
│   └── onboarding-helper/  # Bantu new hire setup environment
└── configs/
    └── team-base.yaml       # Base config yang dipake semua anggota

Ini udah gue terapin di tim dan dampaknya kerasa: onboarding new hire yang dulunya makan 3-4 hari sekarang bisa 1-2 hari karena agent bantu setup environment dan jelasin codebase. Standup meeting juga lebih efisien karena agent udah nyiapin summary dari git log sebelum meeting dimulai.

Membaca Sinyal Pasar: Kenapa Investor Taruh $70 Juta

Buat Teman-Teman yang penasaran dari sisi bisnis, putaran pendanaan Nous Research worth dibahas. Mereka berhasil mengamankan $70 juta dalam funding rounds mereka, dengan investor yang mostly dari kalangan crypto dan decentralized tech—bukan VC AI tradisional.

Ini sinyal yang menarik. Investor tradisional AI biasanya taruh duit di perusahaan yang bikin model (OpenAI, Anthropic, Mistral) atau infrastruktur (CoreWeave, Lambda Labs). Tapi Nous Research dapat duit justru karena thesis mereka yang berbeda: agent sebagai lapisan nilai utama, bukan model.

Dalam beberapa wawancara, Jeffrey Quesnelle (CEO) sering menekankan bahwa mereka nggak mau compete di "model Olympics"—lomba bikin model yang paling besar atau benchmark paling tinggi. Mereka mau bikin infrastruktur yang bikin model apapun jadi berguna di tangan pengguna nyata.

Kalau thesis ini benar, Nous Research ada di posisi yang unik: mereka nggak terancam sama komoditisasi model (karena mereka justru bertaruh di atasnya), dan mereka punya first-mover advantage di decentralized training lewat Psyche.

Kesimpulan

Nous Research bukan sekadar pemain baru di lanskap AI yang lagi hype. Mereka datang membawa thesis yang beda: masa depan nggak dimenangkan oleh siapa yang punya model paling gede, tapi oleh siapa yang paling lihai mengorkestrasi agen-agen cerdas di atas model-model itu. Dari Hermes Agent yang bisa dikustomisasi buat stack infrastruktur khas Indonesia—AWS Singapore, GCP Jakarta, sampai tooling devops lokal—sampai eksperimen decentralized training lewat Psyche, Nous membuktikan bahwa inovasi justru muncul ketika kita berhenti terjebak di "model Olympics" dan mulai mikirin gimana AI beneran bisa dipakai di dunia nyata.

Dampaknya udah mulai kerasa di workflow tim tech Indonesia. Onboarding new hire yang tadinya makan 3–4 hari bisa dipangkas jadi 1–2 hari. Standup meeting jadi lebih terarah karena agent udah nyiapin summary git log sebelum meeting dimulai. Code review makin efisien dengan first-pass otomatis dari agent. Ini bukan efisiensi kosmetik—ini produktivitas yang langsung berdampak ke velocity tim dan bottom line bisnis. Dan yang bikin menarik: semua ini dibangun dengan pendekatan terbuka, bukan di balik tembok proprietary seperti kebanyakan solusi AI enterprise.

Dari sisi bisnis, taruhan \$70 juta dari investor—mayoritas dari kalangan crypto dan decentralized tech—menegaskan bahwa thesis Nous Research nggak cuma menarik secara teknis, tapi juga punya daya tarik pasar yang kuat. Mereka bertaruh bahwa seiring model AI makin terkomoditisasi, nilai justru bergeser ke lapisan agen dan orkestrasi. Kita bisa lihat sendiri bagaimana tren open-source AI terus mengubah lanskap industri.

Gue pribadi excited bukan cuma karena teknologinya, tapi karena apa yang bisa kita bangun di atasnya. Buat Teman-Teman developer, engineering lead, atau founder tech di Indonesia: ini momen yang tepat buat mulai eksperimen. Clone repo Hermes, bikin skill pertama lo, dan rasain sendiri gimana agent-based workflow bisa mengubah cara tim lo bekerja. Karena di dunia di mana semua orang punya akses ke model yang kurang lebih sama, yang bikin lo unggul bukan seberapa canggih model yang lo pakai—tapi seberapa cerdas lo memanfaatkannya.

Referensi

Nous Research. (2026). Nous Research — Open source AI.

Hermes Agent by Nous Research. (2026). Hermes Agent — The open-source agent that grows with you.

LinkedIn. (2026). Nous Research company profile.

AI Wiki. (2026). Nous Research — Applied AI research organization and open-weight language models.

GitHub. (2026). Nous Research organization profile and repositories.

Hugging Face. (2026). NousResearch — Advancing natural language processing through open-source collaboration.

GitHub. (2026). Hermes Agent — The self-improving AI agent with a built-in learning loop.

Baca juga Fine Tuning Model AI Sederhana: Panduan Dasar Praktis

PitchBook. (2026). Nous Research company profile: Valuation, funding, and investors.

Everything-PR. (2026). What is Nous Research? Inside the AI lab behind Hermes.

X. (2026). Nous Research official account posts.