Belajar Hermes AI Agent - Konsep Dasar & Arsitektur Utama

#Pendahuluan

Di episode 1 kalian memahami mengapa Hermes AI Agent unggul: event-driven, plugin extensibility, dan orchestration. Sekarang kita naik satu tingkat lebih dalam: bagaimana Hermes benar-benar bekerja dari dalam.

Roadmap episode ini: kita akan mengenal lima komponen utama — controller, kernel, tools, memory, dan environment — memetakan lifecycle agen dari perception, planning, action, hingga reflection, lalu melihat bagaimana LLM terintegrasi, bagaimana tool invocation berjalan, dan bagaimana menulis custom action pertama.

#Komponen Utama Hermes AI Agent

Hermes dibangun sebagai lima lapis yang saling terhubung. Setiap lapis punya tanggung jawab yang jelas:

Controller adalah komponen yang mengatur alur: menerima pesan masuk, menyusun konteks, memanggil model, mengeksekusi tool, dan mengulang sampai jawaban final. Kernel menyediakan layanan yang dipakai controller — resolusi provider LLM, manajemen konteks, batas iterasi, dan persistensi sesi. Tools adalah fungsi yang terdaftar di registry dan bisa dipanggil model. Memory menyimpan apa yang agent "ingat" lintas sesi. Environment menentukan di mana agent berjalan — CLI, server, atau container — dan lewat platform apa dia diajak bicara.

Pesan Masuk
    |
    v
Controller -> Kernel (provider, konteks) -> LLM
    |                                        |
    |--- tool call? -----------------------> |
    v                                        v
Tools (registry) <-------- hasil eksekusi <- model
    |
    v
Memory & Environment (persistensi, observability)

#Lifecycle Agen: Perception, Planning, Action, Reflection

Setiap putaran conversation di Hermes mengikuti empat fase yang bisa diamati lewat event:

1. Perception: controller membaca input baru ditambah konteks dari memory dan session. Di fase ini agent "melihat" apa yang sedang terjadi.
2. Planning: berdasarkan input, agent menyusun rencana. Hermes mengekspos ini lewat tool todo untuk mencatat subtask dan melacak progres.
3. Action: agent memanggil tool — mengeksekusi kode, membaca file, mencari di web, atau memanggil API. Hasilnya dikembalikan ke model sebagai konteks baru.
4. Reflection: setelah aksi, agent mengevaluasi hasil, menyimpulkan, dan memperbarui memory. Inilah yang membuat Hermes self-improving: ia belajar dari setiap eksekusi.

const agent = new HermesAgent({ profile: "./profiles/support.ts" });
 
agent.on("perception", (ctx) => log.perceive(ctx.userMessage));
agent.on("planning", (plan) => log.plan(plan.tasks));
agent.on("action", (toolCall) => log.act(toolCall.name));
agent.on("reflection", (summary) => log.reflect(summary));
 
const answer = await agent.run("Analisis log hari ini dan kirim ringkasan.");

Empat fase ini bukan sekadar teori — dengan men-subscribe event seperti di atas, kalian bisa memantau apa yang agent pikirkan dan lakukan, yang menjadi dasar observability di episode 7.

#Integrasi LLM dan Tool Invocation

Setiap fase lifecycle mengarah ke satu hal: pertukaran pesan dengan LLM. Controller menyusun riwayat percakapan plus definisi tool (schema) ke dalam satu request, lalu model memilih jawaban teks atau satu atau lebih tool call.

{
  "type": "function",
  "function": {
    "name": "getStockLevel",
    "description": "Mengambil level stok produk berdasarkan SKU",
    "parameters": {
      "type": "object",
      "properties": {
        "sku": { "type": "string" }
      },
      "required": ["sku"]
    }
  }
}

Saat model mengembalikan tool call, controller mencarinya di registry, mengeksekusi handler-nya, lalu memasukkan hasilnya sebagai pesan tool ke riwayat dan mengirim request berikutnya. Loop ini berjalan dalam batas iterasi yang diatur kernel — default 90 iterasi — untuk mencegah agent berputar tanpa akhir. Paham alur ini penting sebelum kita menulis custom action.

#Custom Action: Tool Pertama Kalian

Custom action adalah fungsi biasa yang didaftarkan ke registry. Contoh nyata: tool untuk mengecek stok dari API internal.

import { defineTool } from "@hermes/sdk";
 
export const getStockLevel = defineTool({
  name: "getStockLevel",
  description: "Mengambil level stok produk berdasarkan SKU",
  parameters: {
    type: "object",
    properties: {
      sku: { type: "string" },
    },
    required: ["sku"],
  },
  async handler(args, ctx) {
    const res = await ctx.http.get(`/api/inventory/${args.sku}`);
    return JSON.stringify({ sku: args.sku, level: res.data.level });
  },
});

Perhatikan anatominya: name dan description menjadi petunjuk bagi model kapan tool ini dipakai; parameters adalah schema JSON yang memvalidasi argumen; handler adalah eksekusi sebenarnya, dengan akses ke konteks seperti ctx.http. Daftarkan di config agent dan tool ini langsung tersedia untuk dipanggil model — tanpa menyentuh kernel sama sekali.

#Penutup

Episode 2 membuka kotak hitam Hermes: lima komponen yang saling terhubung, lifecycle empat fase yang bisa diamati lewat event, integrasi LLM melalui tool invocation yang ter-loop, dan custom action pertama yang berdiri sendiri tanpa menyentuh kernel.

Inti yang harus dibawa pulang:

• Controller mengorkestrasi; kernel menyediakan layanan; tools, memory, dan environment melengkapi sisanya.
• Lifecycle agent berjalan pada empat fase: perception, planning, action, reflection.
• Tool invocation adalah loop: model memilih tool, runtime mengeksekusi, hasilnya kembali ke model.
• Iteration budget menjaga agent agar tidak berputar tanpa batas.
• Custom action cukup didaftarkan ke registry — extensibility tanpa menyentuh kernel.

Di episode 3 selanjutnya kita akan turun ke praktik nyata: instalasi dan setup dasar — menyusun project Hermes Agent, menginstal dependensi, mengonfigurasi runtime dan provider model, lalu menjalankan agent lokal pertama kalian. Arsipkan pemahaman arsitektur ini, karena akan menjadi peta saat kita mulai ngoprek!