delegate_task di Hermes: Cara Spawn Subagent dan Kapan Harus Pakai

Bayangkan lo punya workflow yang harus menyelesaikan tiga hal sekaligus: analisis data mentah, penulisan laporan, dan review stakeholder. Kalau semua dikerjakan berurutan, total waktunya tiga kali lipat. Tapi apa lo tidak bisa pecah jadi tiga subagent yang bekerja paralel? Ini dia cara memanfaatkan delegate_task di Hermes untuk context isolation dan parallel workstream—tanpa bikin skeleton codebase.

Apa Itu delegate_task

delegate_task adalah mekanisme built-in Hermes yang memungkinkan agent utama spawn subagent dengan konteks tertentu. Bukan thread atau coroutine—inilah benar-benar agent terpisah yang dapat berinteraksi dengan environment yang sama namun dengan scope tertentu. Artinya, setiap subagent punya "workspace" tersendiri, data yang dia baca/tulis tidak langsung memengaruhi state lain kecuali lo explicit minta.

Fungsinya mirip dengan fork() di sistem operasi: proses anak (subagent) melanjutkan dari titik tertentu dengan data tertentu, lalu kembali ke proses induk (orchestrator) setelah selesai. Bedanya, di Hermes kita tidak mengelola memory atau thread scheduling—Hermes yang urusi.

Kapan Delegate vs Eksekusi Langsung

Rule of thumb sederhana: delegate jika ada sebagian pekerjaan yang membutuhkan konteks tertentu atau task yang bersifat stateless dan dapat dijalankan paralel. Kalo cuma sekadar loop sederhana atau panggilan API yang sudah diketahui hasilnya, eksekusi langsung lebih baik.

Contoh konkrit:

• Delegate: Membuat laporan dari dataset besar (butuh waktu lama, banyak memory)
• Eksekusi langsung: Mengambil data dari API yang sudah ada (cepat, satu baris kode)

Yang sering terjadi, developer langsung delegate tanpa mikro-analisis. Itu bikin waste token karena subagent butuh overhead untuk startup dan komunikasi kembali ke orchestrator.

Context Passing yang Benar ke Subagent

Ini kan poin kesulitan utama. Lo gak bisa cuma delegate_task("analisis data"). Subagent butuh konteks: data apa yang harus dianalisis, aturan apa yang harus diterapkan, output yang diharapkan bentuk apa.

Contoh kode minimal:

result = delegate_task(
    role="data_analyst",
    task="Analisis sales Q1 2026, temukan outlier",
    context={
        "dataset_url": "https://s3.example.com/sales_q1_2026.csv",
        "rules": ["outlier > 2 std dev", "rekomendasikan aksi"]
    },
    expected_output="list outlier + rekomendasi"
)

Konteks di sini harus serializable JSON karena Hermes pakai HTTP/JSON buat komunikasi antar agent. Jangan kirim object Python langsung. Kalo data besar, pertimbangkan reference file atau URL, bukan object mentah.

Leaf vs Orchestrator Role

Di dalam arsitektur Hermes, biasanya ada dua level peran:

1. Orchestrator: Agent utama yang tahu goal akhir, tapi tidak harus tahu detail tiap step. Ia justru koordinasi subagent.
2. Leaf: Subagent yang fokus satu domain (misalnya data_analyst, report_writer, stakeholder_reviewer).

Kalo lo selalu menulis semua logika di satu agent, lo memang belum pake delegate_task dengan benar. Tujuan utama delegate adalah isolasi tanggung jawab. Setiap leaf agent seharusnya hanya fokus ke tugasnya masing-masing.

Contoh workflow:

• Orchestrator: "Buatin laporan penjualan"
  - Delegate ke data_analyst: "Temukan tren penjualan"
  - Delegate ke report_writer: "Susun laporan dengan temuan"
  - Callback ke orchestrator untuk final review

Anti-pattern: Delegate untuk Task Trivial

Ini yang sering terjadi di kalangan developer baru. Mereka delegate untuk:

• Konversi satu field JSON
• Validasi input sederhana
• Logging

Semua itu bisa dikerjakan dengan satu baris kode di agent utama. Kalo lo delegate terus-terusan, lo ngga benar-benar manfaatkan parallel execution. Malah bikin latency lebih tinggi karena overhead communication.

Kalibrasi: tanya diri lo, "kalau task ini dikerjakan dalam 50ms, apakah worth it buat spawn subagent?" Kalo iya, delegate. Kalo ngga, eksekusi langsung.

Cara Verify Output Subagent Tanpa Trust Blind

Ini sering diabaikan. Lo asumsikan subagent jawabannya benar. Tapi bagaimana lo tahu outputnya tidak korup atau tidak lengkap?

Strategi tiga lapisan:

1. Schema validation: Setelah delegate selesai, cek apakah output sesuai dengan expected_output yang lo tentukan. Contoh: harus ada field data dan summary.
2. Cross-check: Kalo memungkinkan, delegate ke dua subagent yang sama dengan input yang sama, bandingin hasilnya.
3. Sanity check ringan: Contoh, kalau hasil analisis data berupa list angka, pastikan tidak ada nilai negatif kalau tidak masuk akal.

Contoh implementasi:

def validate_subagent_output(output, schema):
    try:
        jsonschema.validate(output, schema)
        return True
    except jsonschema.ValidationError as e:
        log_error(f"Subagent output invalid: {e}")
        return False

Kalo gagal, orchestrator bisa retry atau fallback ke mode manual.

Praktik Terbaik: Pemilihan Role yang Tepat

Setiap subagent harus punya role yang jelas dan tidak tumpang tindih. Contoh role yang baik:

• data_processor: fokus ke transformasi dan validasi data
• analyzer: fokus ke statistik, pola, outlier
• writer: fokus ke penulisan konten dengan gaya tertentu

Kalo lo bikin role "super agent" yang bisa ngapain, lo justru mengkhianati tujuan utama delegate_task: isolasi tanggung jawab.

Debugging Delegate Task

Kadang subagent malah return kosong atau error. Cara debug-nya:

1. Check log subagent secara terpisah. Hermes biasanya nyimpen log tiap agent.
2. Test manual satu per satu. Jalankan delegate_task satu task, lihat hasilnya dulu.
3. Gunakan timeout. Kalo subagent hanging, Hermes bisa kill otomatis setelah X detik.

Contoh:

result = delegate_task(
    role="analyzer",
    task="...",
    timeout=30
)

Kalo timeout, orchestrator bisa lanjut ke alternatif lain atau kasih feedback ke user.

Kapan Harus Hindari delegate_task

• Data sangat sensitif: Kalo data harus diproses di environment tertentu, delegate ke subagent luar bisa bikin leak.
• Latency kritis: Kalo lo butuh jawaban dalam 100ms, overhead delegate_task bisa menambah 200ms.
• Kurangnya resource: Kalo device running Hermes dengan memory/CPU terbatas, spawning banyak subagent bisa bikin sistem crash.

Ringkasan Workflow dengan delegate_task

1. Identifikasi task yang cocok (berat, paralel, butuh konteks khusus)
2. Buat schema input/output yang jelas
3. Delegate ke subagent dengan role yang spesifik
4. Validasi output secara otomatis
5. Koordinasi kembali ke orchestrator untuk step berikutnya

Kamu tau, 80% developer yang pakai Hermes cuma memakai 20% fiturnya. Salah satu yang paling disia-siakan adalah delegate_task. Tapi kebanyakan gak paham kapan harus memakainya.

Coba identifikasi satu task di workflow lo yang cocok didelegasikan. Mungkin itu analisis log, proses data CSV, atau bahkan generate draft email. Spawn satu subagent dulu. Perhatikan perbedaan waktu respons dan kualitas output.

Yang sampai sekarang, belum pernah liat team yang memakai delegate_task secara efektif merebut 30% waktu development mereka. Dengan isolasi konteks dan parallel execution, lo bisa ngurang bottleneck tanpa nambahin infrastructure.

Mulai dari contoh kecil. Satu delegate_task. Satu workflow baru.