Hermes Agent: My containerized take

services:
  hermes:
    image: nousresearch/hermes-agent:v0.21.6
    container_name: hermes
    restart: unless-stopped
    command: gateway run

    shm_size: "4gb"

    depends_on:
      searxng:
        condition: service_healthy
      signal:
        condition: service_started

    ports:
      - "9119:9119"

    volumes:
      - ${HOME}/.hermes:/opt/data
      - /var/run/docker.sock:/var/run/docker.sock

    environment:
      HERMES_UID: "10000"
      HERMES_GID: "10000"
      HERMES_DASHBOARD: "1"
      HERMES_DASHBOARD_HOST: "0.0.0.0"
      TZ: Europe/Amsterdam

  searxng:
    image: searxng/searxng:2026.10.9-f4822b3fc
    container_name: searxng
    restart: unless-stopped

    ports:
      - "127.0.0.1:8888:8080"

    volumes:
      - ${HOME}/.searxng/config:/etc/searxng
      - searxng-cache:/var/cache/searxng

    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "--proxy=off", "http://127.0.0.1:8080/healthz"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 15s

  signal:
    image: registry.gitlab.com/packaging/signal-cli/signal-cli-jre:v0-14-9-2
    container_name: signal
    restart: unless-stopped
    command: daemon --http 0.0.0.0:8080

    volumes:
      - ${HOME}/.signal:/var/lib/signal-cli

networks:
  default:
    name: hermes

volumes:
  searxng-cache:
    name: searxng-cache

_config_version: 50

model:
  base_url: ${VLLM_API_URL}
  default: ${VLLM_API_MODEL}
  provider: custom
  api_key: ${VLLM_API_KEY}

delegation:
  model: ${VLLM_DELEGATION_MODEL}
  provider: custom
  base_url: ${VLLM_DELEGATION_URL}
  api_key: ${VLLM_DELEGATION_KEY}
  api_mode: chat_completions
  max_iterations: 500
  reasoning_effort: medium
  max_concurrent_children: 2
  max_spawn_depth: 2
  orchestrator_enabled: true
  compression_threshold_tokens: 98304

agent:
  max_turns: 0
  system_prompt: |
    # Delegation policy

    Use delegation deliberately to improve results, parallelize
    independent work, and keep detailed investigations out of the
    main conversation.

    Before substantial tasks, evaluate whether delegation
    would provide a real advantage.

    Delegate when:
    - A task has independent research or analysis workstreams.
    - A bounded investigation requires substantial tool use.
    - Independent review would materially improve correctness.
    - A subtask can produce a clear, independently verifiable result.

    Work directly when:
    - The answer is straightforward.
    - The task requires only one or two simple tool calls.
    - Delegation would add overhead without improving the result.
    - Work is purely mechanical and better handled by execute_code.

    Delegation execution:
    - Use the delegate_task tool, not a simulated delegation.
    - Prefer one batch containing up to two independent tasks.
    - Give each child a specific, self-contained goal and context.
    - Include relevant file paths, constraints, expected output,
      and acceptance criteria in each child's context.
    - Do not assume children know the parent conversation,
      personality instructions, or previous tool results.
    - Never parallelize dependent tasks; dispatch later stages
      after their prerequisites finish.
    - Allow nested delegation only when it provides real value.
    - Keep final synthesis, decisions, and integration with
      the parent agent.

    Verification:
    - Treat child summaries as unverified reports.
    - Check material claims, generated files, tests, and changes.
    - Do not claim success solely because a child completed.
    - If a child fails, retry with a narrower task or handle
      the remaining work directly.

    Background execution:
    - After dispatching, complete other independent work.
    - If nothing independent remains, end the turn.
    - Do not poll child transcripts or repeatedly check status.
    - Continue synthesis when delegation results are delivered.

    Be concise and direct. Do not narrate delegation decisions
    unless useful to the user.

    # Internet research policy

    Use internet research proactively when external information
    would materially improve accuracy or usefulness.

    Search when:
    - Information may have changed since training.
    - Questions concern software, APIs, documentation, releases,
      security advisories, or compatibility.
    - The user requests research, comparisons, or verification.
    - Important facts are unfamiliar, uncertain, or disputed.

    Avoid unnecessary searches for straightforward questions
    or tasks involving only user-provided content.

    Research workflow:
    - Use web_search to discover sources through SearXNG.
    - Use browser_navigate to open relevant webpages locally.
    - Read the snapshot returned by browser_navigate.
    - Use browser_snapshot when additional page context is needed.
    - Follow relevant links when deeper verification is required.
    - Prefer official documentation, primary sources, and
      authoritative publications.
    - Check publication dates and software versions.
    - Cross-check consequential claims using independent sources.
    - Distinguish verified facts from assumptions.
    - Include source URLs for externally verified claims.
    - Never fabricate findings, quotations, or sources.
    - Do not expose secrets in search queries or URLs.

    Tool selection:
    - Prefer web_search for discovering information.
    - Prefer browser_navigate for reading webpages.
    - Use browser interactions for JavaScript-rendered content.
    - Use web_extract only if a working extraction provider
      is configured.
    - Avoid browser automation when simpler available tools
      can reliably complete the task.

    Research and delegation:
    - Delegate substantial, independent research workstreams.
    - Require children to return findings and source URLs.
    - Give children clear research questions and constraints.
    - Verify important child findings before final synthesis.
    - Handle small lookups directly without delegation.

    If a tool fails, use an appropriate available alternative.
    Never claim to have verified information that was not read.

compression:
  enabled: true
  threshold_tokens: 131072
  tail_mode: lean
  in_place: true
  context_timeout_seconds: 600

auxiliary:
  compression:
    model: ${VLLM_COMPRESSION_MODEL}
    base_url: ${VLLM_COMPRESSION_URL}
    api_key: ${VLLM_COMPRESSION_KEY}
    timeout: 600
    max_concurrency: 2

telemetry:
  shared_metrics:
    enabled: false
    send: false
    offer_version: 2

web:
  search_backend: searxng

browser:
  cloud_provider: local

platforms:
  signal:
    enabled: true

mcp_servers:
  github:
    command: "docker"
    args:
      - "run"
      - "-i"
      - "--rm"
      - "-e"
      - "GITHUB_PERSONAL_ACCESS_TOKEN"
      - "-e"
      - "GITHUB_TOOLSETS"
      - "ghcr.io/github/github-mcp-server:v2.0.2"

    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: "${GITHUB_TOKEN}"
      GITHUB_TOOLSETS: "all"

    timeout: 120
    connect_timeout: 60

  context7:
    command: "docker"
    args:
      - "run"
      - "-i"
      - "--rm"
      - "-e"
      - "MCP_TRANSPORT=stdio"
      - "-e"
      - "CONTEXT7_API_KEY"
      - "mcp/context7:latest"

    env:
      CONTEXT7_API_KEY: "${CONTEXT7_API_KEY}"

    timeout: 120
    connect_timeout: 60