Hermes Agent Subagent Delegation: One Boss, Three AI Workers for Solopreneurs (2026)

Solo founders hit the same wall: you are the researcher, the data janitor, and the copywriter—often in one afternoon. Hermes Agent from Nous Research ships a built-in delegate_task tool that spawns isolated child agents with their own terminal sessions. The parent acts as coordinator; each child gets a fresh conversation, a focused goal, and a restricted toolset—only the final summary returns to the boss context.

You do not hand-write orchestration classes like CrewAI. Describe outcomes in plain language—find sources, normalize a CSV, draft the newsletter—and Hermes fans out up to 3 parallel subagents by default (delegation.max_concurrent_children). New to install? See our Hermes macOS setup guide or the Hermes Mac mini M4 runbook for always-on Mac patterns.

Why delegate_task beats hand-rolled multi-agent code

Frameworks like CrewAI expect roles, tasks, and dependencies in Python. Hermes inverts that: the parent LLM decides when to delegate.

Under the hood, delegate_tool constructs child agents with zero parent history, separate terminal sessions, token-efficient summaries, and parallel batch mode (default max 3).

Frameworks like CrewAI expect you to define roles, tasks, and dependencies in Python before the workflow is validated on real data. Hermes inverts that: the parent LLM decides when to delegate based on task complexity. Under the hood, tools/delegate_tool.py constructs child AIAgent instances with separate terminal sessions.

Each subagent receives a system prompt derived from goal (what to achieve) and context (paths, formats, constraints). Upstream docs warn: goal="Fix the error" fails because the child never saw the error—paste stack traces, directory paths, and output schemas into context.

Leaf subagents cannot call delegate_task, clarify, memory, send_message, or execute_code—the parent must front-load instructions in context because children cannot ask clarifying questions mid-flight.

Parallel batches default to three children. Research, CSV normalization, and drafting can run concurrently when paths do not overlap. If two legs need the same file, serialize them in the boss brief.

For mechanical transforms (sort 10k rows, no judgment), upstream recommends execute_code instead—cheaper tokens, no reasoning loop.

Subagents inherit the parent's API credentials unless overridden—useful for rate-limit rotation across parallel workers.

Operationally, treat delegate_task as a contract: you supply outcomes, paths, and schemas; the parent decomposes and spawns; you audit files on disk. Persist sources.csv and draft.md weekly so failures are cheap single-leg reruns.

When comparing CrewAI repositories with Hermes on a Mac, ask how often your pipeline changes. Fixed DAGs shine for nightly ETL; one-person newsletter loops change weekly—Hermes lets you describe a new triangle in plain language.

Quotable: Leaf subagents cannot call delegate_task, clarify, memory, send_message, or execute_code—the parent must front-load context.

Source: Hermes Subagent Delegation docs.

Architecture: boss, workers, and toolsets

Each subagent receives prompts from goal and context. Paste stack traces, paths, and schemas—children never saw your parent thread.

Blocked toolsets for leaf workers include delegation (no recursive spawn unless orchestrator role), memory, and clarify.

You (solopreneur)
    │
    ▼
Hermes parent agent  ──delegate_task(tasks=[A, B, C])──┐
    │                                                   │
    │                    ┌──────────────┬──────────────┐  │
    │                    ▼              ▼              ▼  │
    │              Subagent A      Subagent B    Subagent C
    │              toolsets:web    terminal+file  web+file
    │                    │              │              │
    │                    └──── summaries back to parent ──┘
    ▼
Final merged brief / files on disk

Optional ~/.hermes/config.yaml delegation block sets max_iterations, concurrency, timeouts, and a cheaper subagent model.

Subagents inherit parent API credentials unless overridden.

delegation:
  max_iterations: 50
  max_concurrent_children: 3
  child_timeout_seconds: 600
  model: "google/gemini-2.0-flash-001"
  provider: "openrouter"

Plan worker boundaries before spawning—children cannot ask you clarifying questions mid-flight.

Solopreneur workflow: three AI employees

Imagine weekly content ops for a one-person SaaS newsletter:

You do not call Python APIs for daily use—the boss prompt in the Hermes TUI drives delegate_task batches.

In the Hermes TUI, give the boss prompt:

Run this week's newsletter pipeline for topic "Mac mini CI for iOS teams":
1) Delegate research: 10 authoritative sources from 2025–2026.
2) Delegate data: save title,url,summary into ~/work/newsletter/sources.csv.
3) Delegate writing: draft draft.md (~800 words) using only that CSV.
Use parallel delegation where safe. Report file paths when done.

Hermes should emit a delegate_task batch resembling upstream examples:

delegate_task(tasks=[
    {
        "goal": "Research Mac mini CI for iOS teams",
        "context": "Need 10 sources from 2025–2026. Prefer Apple, GitHub Actions, and Mac host vendors. Return bullet list with URLs.",
        "toolsets": ["web"]
    },
    {
        "goal": "Build sources.csv from research output",
        "context": "CSV columns: title,url,summary. Path: ~/work/newsletter/sources.csv. Create directory if missing.",
        "toolsets": ["terminal", "file"]
    },
    {
        "goal": "Draft newsletter markdown",
        "context": "Read ~/work/newsletter/sources.csv only. Write ~/work/newsletter/draft.md ~800 words, H2 sections, no fabricated URLs.",
        "toolsets": ["file"]
    }
])

The parent merges summaries; you review artifacts on disk. For mechanical transforms, prefer execute_code.

Step-by-step runbook on macOS

This eight-step runbook assumes Hermes is already on a Mac you control. Each step maps to install docs, tool toggles, workspace layout, and review habits solopreneurs reuse weekly.

1. Install Hermes — If missing, follow the Hermes macOS setup guide: curl -fsSL …/install.sh | bash, then hermes doctor.
2. Enable tools — Run hermes tools and confirm delegation, web, terminal, and file toolsets are on.
3. Create workspace — mkdir -p ~/work/newsletter so every context block shares a concrete path.
4. Optional config — Add the delegation: YAML block to ~/.hermes/config.yaml for cheaper subagent models or >3 concurrency.
5. Reusable skill (optional) — Save ~/.hermes/skills/newsletter-pipeline/ with your three-worker boss instructions for weekly reload via /skills.
6. Run the boss session — hermes, paste the pipeline prompt, watch delegation in the TUI. Use /agents (alias /tasks) for live trees, token rollups, and kill controls.
7. Review outputs — Open sources.csv and draft.md; rerun only failed legs via a single corrected delegate.
8. Schedule (optional) — For recurring runs, use Hermes cron documentation instead of expecting background delegate_task to survive parent Ctrl+C—delegation is synchronous in the parent turn.

Troubleshooting

Subagent returns empty or generic summary

Symptom: Child completes in a few seconds with useless output.

Fix: The parent under-specified context. Re-run with explicit paths, schemas, and examples. Subagents start with zero parent history.

Batch fails with concurrency error

Symptom: Tool error when passing four or more tasks in one batch.

Fix: Default max_concurrent_children is 3. Split into sequential batches or raise the limit in ~/.hermes/config.yaml or DELEGATION_MAX_CONCURRENT_CHILDREN.

Subagent timeout at 600 seconds

Symptom: child_timeout_seconds kills mid-research.

Fix: Increase delegation.child_timeout_seconds for slow models, or narrow the goal. Check ~/.hermes/logs/subagent-timeout-*.log if zero API calls occurred.

delegate_task vs execute_code

Pick the right tool before spawning three reasoning loops—token cost and interrupt behavior differ.

Apple's Mac mini specifications list 16GB unified memory on base M4—enough for one parent plus three concurrent subagents; choose 24GB with browser-heavy tools.

For faceless video output (not just text pipelines), pair delegation with MoneyPrinterTurbo faceless Shorts tutorial —67K+ GitHub stars, 8-step macOS batch runbook for Douyin / Shorts / Xiaohongshu.

Pair delegate_task with our Hermes Gateway multi-device setup for Telegram→Discord handoff.

FAQ

Do I need CrewAI if I use Hermes subagents?

No for ad-hoc workflows. Hermes embeds orchestration in the parent model via delegate_task. CrewAI still wins when you want version-controlled Python DAGs inside an app repo—but solopreneur newsletter and ops loops rarely need that ceremony.

How many parallel subagents can Hermes spawn?

3 by default, configurable with no hard ceiling upstream—batches larger than the limit return an error until you raise max_concurrent_children.

Can subagents talk to me on Telegram?

Not directly. Leaf subagents cannot use send_message or clarify. The parent gateway session relays final merged answers. Run hermes gateway for phone-side boss chat.

Will children remember last week's research?

Not automatically. Leaf subagents cannot write memory. Persist artifacts to disk (sources.csv, draft.md) or let the parent curate memory after reviewing summaries.

Does this require a cloud Mac?

No. Any awake Mac with Hermes installed works. A sleeping laptop pauses long batch runs—teams that delegate from Telegram while workers run elsewhere often use an always-on Mac.

Related reading: Hermes macOS setup guide for install, gateway, and launchd; Hermes Mac mini M4 runbook for always-on Mac mini hosting—no pricing tables here.

Related reading

• GPT-5.6 Predictions: Codex Open Source for Agent Efficiency