Hermes Agent 的 delegate_task 工具让你可以并行启动子 Agent——一个负责研究，另一个负责编码，第三个运行测试。但强大的并行能力也带来了混乱：每个子 Agent 运行在同一个宿主环境中，共享依赖项、进程冲突、或误写的文件都可能引发微妙的 bug。本指南展示如何在 Docker 容器中隔离子 Agent，通过 PostgreSQL 协调共享状态，以及使用 Git 管理产出物——这是团队在生产环境中大规模运行多 Agent 工作流的成熟模式。
默认情况下，Hermes 子 Agent 继承父会话的终端会话和工作目录。同时委派三个子 Agent，它们都看到相同的文件系统：
$ ls /root/yiman_workspace/
Dockerfile
agent-a-output/
agent-b-output/
README.md # 等等——这是哪个 Agent 写的？更糟的是，一个子 Agent 中冲突的 Python 依赖项或后台进程可能导致另一个子 Agent 崩溃。解决方案是每个子 Agent 一个 Docker 容器——每个子 Agent 拥有独立的文件系统、进程命名空间和依赖集合。父 Hermes Agent 保持为编排者，通过共享的 PostgreSQL 状态存储和 Git 与子 Agent 通信以交换产出物。
该模式分为三层：
delegate_task 并分配工作的父 Hermes Agent 会话┌──────────────────────────────────────┐
│ 父 Hermes Agent 会话 │
│ （编排者——分解工作） │
└──────┬───────────┬───────────┬───────┘
│ │ │
delegate_task delegate_task delegate_task
│ │ │
┌────▼────┐ ┌───▼────┐ ┌───▼────┐
│Agent A │ │Agent B │ │Agent C │
│Docker │ │Docker │ │Docker │
│容器 │ │容器 │ │容器 │
└────┬────┘ └───┬────┘ └───┬────┘
│ │ │
└───────────┼───────────┘
│
┌─────────▼─────────┐
│ PostgreSQL │
│（任务状态、锁） │
└───────────────────┘从环境开始。每个子 Agent 容器运行在同一个 Docker 宿主机上，并共享一个桥接网络以访问 PostgreSQL：
$ docker --version
Docker version 28.5.1, build e180ab8
$ docker network create agent-bridge
c4e5d6f7a8b9c0d1e2f3a4b5c6d7e8f9
$ docker network ls | grep agent
c4e5d6f7a8b9 agent-bridge bridge local子 Agent 的 Dockerfile 包含 Hermes Agent、Git 和 PostgreSQL 客户端：
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y \
python3 python3-pip python3-venv \
git curl ca-certificates postgresql-client \
&& rm -rf /var/lib/apt/lists/*
# 安装 Hermes Agent
RUN python3 -m venv /opt/hermes-venv && \
/opt/hermes-venv/bin/pip install hermes-agent
# 安装 Playwright 用于浏览器自动化
RUN /opt/hermes-venv/bin/playwright install-deps && \
/opt/hermes-venv/bin/playwright install
# Hermes 配置
ENV HERMES_HOME=/subagent/.hermes
ENV PATH="/opt/hermes-venv/bin:$PATH"
WORKDIR /workspace
# 入口点：子 Agent 作为一次性 hermes 进程运行
ENTRYPOINT ["hermes", "chat", "-q"]构建一次镜像，然后按需启动子 Agent 容器：
$ docker build -t hermes-subagent:latest -f Dockerfile.subagent .
$ docker run -d --name subagent-build --network agent-bridge \
-e PGHOST=postgres -e PGDATABASE=agent_state \
-e HERMES_API_KEY=*** \
--cpus=2 --memory=4g \
hermes-subagent:latest "运行 ~/project 的测试并报告结果"--cpus 和 --memory，三个并行子 Agent 可能耗尽宿主机资源。每个子 Agent 限制 2 个 CPU 核心和 4 GB 内存——编排者可以在当前子 Agent 完成后启动更多。子 Agent 需要知道其他子 Agent 在做什么。一个共享的 PostgreSQL 表提供轻量级协调层：
$ docker run -d --name agent-postgres --network agent-bridge \
-e POSTGRES_DB=agent_state -e POSTGRES_PASSWORD=*** \
-v pgdata:/var/lib/postgresql/data \
postgres:16-alpine
$ docker exec agent-postgres psql -U postgres -d agent_state -c "
CREATE TABLE tasks (
id SERIAL PRIMARY KEY,
agent_id TEXT NOT NULL,
status TEXT DEFAULT 'pending',
artifact_path TEXT,
result JSONB,
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW()
);"
CREATE TABLE每个子 Agent 在启动和完成时将状态写入 tasks 表。编排者轮询此表以决定下一步操作：
$ docker exec agent-postgres psql -U postgres -d agent_state -c \
"SELECT agent_id, status, artifact_path FROM tasks ORDER BY id DESC LIMIT 5;"
agent_id | status | artifact_path
-------------------+------------+----------------
subagent-research | completed | /workspace/research/summary.md
subagent-build | in_progress|
subagent-test | pending |
(3 rows)这是轻量级协调——不是消息队列。对于生产流水线，结合 Hermes Agent 内置的 delegate_task 批量模式，让并行处理原生可用：
# Hermes 父会话调用：
delegate_task(tasks=[
{"goal": "研究 Docker 隔离模式", "context": "..."},
{"goal": "构建子 Agent Dockerfile", "context": "..."},
{"goal": "测试多 Agent 协调", "context": "..."}
])批量运行上限为 max_concurrent_children（默认 3 个），并行执行无需 PostgreSQL 轮询。数据库层用于持久化状态——任务历史、跨运行分析和事后调试。
子 Agent 产生产出物——代码、配置文件、报告。Git 是交换媒介。每个子 Agent 将输出提交到共享仓库；其他子 Agent 从同一仓库拉取：
$ git --version
git version 2.34.1
$ docker exec subagent-research git -C /workspace/project status
On branch agent/research-summary
nothing to commit, working tree clean
$ docker exec subagent-research git -C /workspace/project log --oneline -3
abc1234 添加 Docker 隔离模式研究摘要
def5678 初始化子 Agent 工作空间
ghi9012 合并父编排者设置模式如下：
实用的分支命名规范让一切井然有序：
# 每个子 Agent 拥有自己的分支
agent/research-docker-isolation # 子 Agent A
agent/build-dockerfile # 子 Agent B（在 A 的工作基础上构建）
agent/test-multi-coordination # 子 Agent C（在 B 的工作基础上构建）编排者在所有子 Agent 完成后合并：
$ git merge agent/research-docker-isolation
$ git merge agent/build-dockerfile
$ git merge agent/test-multi-coordination
$ git push origin mainconfig.yaml）时，Git 合并冲突就会发生。编排者或专门的"冲突解决"子 Agent 来处理。生产环境中，优先选择不重叠的子 Agent 边界——为每个子 Agent 分配独立的目录或文件前缀。如果子 Agent 需要自行构建或运行 Docker 容器，你有两种选择：
将宿主机 Docker socket 挂载到子 Agent 容器中——干净、快速，使用同一个 Docker 守护进程：
$ docker run -d --name subagent-docker \
-v /var/run/docker.sock:/var/run/docker.sock \
--network agent-bridge \
hermes-subagent:latest \
"构建并测试 ~/project 的 Docker 镜像"如需完全隔离，在子 Agent 容器内运行独立的 Docker 守护进程。速度较慢但完全隔离：
$ docker run -d --name subagent-dind \
--privileged \
--network agent-bridge \
docker:dind
$ docker run -d --name subagent-build \
--network agent-bridge \
-e DOCKER_HOST=tcp://subagent-dind:2375 \
hermes-subagent:latest "docker build -t my-image ."--privileged 标志削弱安全性。仅在子 Agent 必须在完全隔离的 Docker 环境中运行时（例如测试不受信任的 Dockerfile）才使用 dind。以下是一个真实的工作流：父 Hermes Agent 将一个功能拆分为三个并行子 Agent 任务，每个任务隔离在自己的 Docker 容器中：
# 1. 父 Hermes Agent 批量派发 3 个子 Agent
delegate_task(tasks=[
{
"goal": "研究异步 Python Agent 的最佳 PostgreSQL 连接池。将结果写入 /workspace/research/pg-pool.md",
"context": "在 ~/project 中工作。使用 asyncpg 和 SQLAlchemy 基准测试。",
"toolsets": ["terminal", "file", "web"]
},
{
"goal": "为 Hermes 子 Agent 实现基于 PostgreSQL 的任务状态存储。从 /workspace/research/pg-pool.md 读取研究成果",
"context": "在 ~/project 中工作。Schema：tasks(id, agent_id, status, artifact_path, result, timestamps)。使用 Python + asyncpg。",
"toolsets": ["terminal", "file"]
},
{
"goal": "编写 3 子 Agent 系统的 Docker Compose 编排配置，包含 PostgreSQL。从共享工作空间读取实现。",
"context": "在 ~/project 中工作。包含健康检查、资源限制和桥接网络。",
"toolsets": ["terminal", "file"]
}
])每个子 Agent 在自己的 Docker 容器中运行并受资源限制，通过 PostgreSQL 共享状态，通过 Git 交换产出物。编排者等待所有三个完成，然后合并它们的分支：
$ git log --oneline --graph --all
* 3c4d5e6 (agent/test-docker-compose) 为 3 子 Agent 系统添加 Docker Compose
* 2b3c4d5 (agent/implement-pg-store) 实现 PostgreSQL 任务状态存储
* 1a2b3c4 (agent/research-pg-pool) 研究：asyncpg vs SQLAlchemy 用于 Agent
* 0z9y8x7 (main) 初始项目骨架编排者审查每个分支，合并到 main，最终产出是一个生产就绪的多 Agent 协调系统——由三个 Docker 隔离的子 Agent 并行构建。
Hermes Agent 的 delegation 配置节控制子 Agent 行为。Docker 隔离子 Agent 的关键设置：
$ hermes config edit
# 相关的 delegation 配置：
# delegation:
# max_concurrent_children: 3 # 并行子 Agent 上限
# max_spawn_depth: 1 # 嵌套限制（1 = 仅叶节点）
# max_iterations: 50 # 每个子 Agent 的最大 LLM 调用次数
# model: deepseek-v4-pro # 子 Agent 模型
# provider: deepseek # 子 Agent 提供商查看当前 delegation 设置：
$ hermes config get delegation
delegation.max_concurrent_children: 3
delegation.max_spawn_depth: 1
delegation.max_iterations: 50对于 Docker 隔离的子 Agent，保持 max_spawn_depth: 1——每个子 Agent 是叶节点，不能进一步委派。这防止容器蔓延（子 Agent 递归生成子子 Agent）。如果需要更深的嵌套，增加 max_spawn_depth 并确保 Docker 宿主机能承受这种乘法增长。
使用 Docker 原生的自省功能追踪子 Agent 容器状态：
$ docker ps --format "table {{.Names}}\t{{.Status}}\t{{.RunningFor}}" | grep subagent
subagent-research Up 12 minutes 12 minutes
subagent-build Up 5 minutes 5 minutes
subagent-test Up 2 minutes 2 minutes监控资源消耗以捕获失控的子 Agent：
$ docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}" | grep subagent
subagent-research 23.45% 1.2GiB / 4GiB
subagent-build 45.12% 2.8GiB / 4GiB
subagent-test 8.30% 0.5GiB / 4GiB对于历史分析，查询 PostgreSQL 任务历史：
$ docker exec agent-postgres psql -U postgres -d agent_state -c "
SELECT agent_id, status, created_at,
EXTRACT(EPOCH FROM (updated_at - created_at)) AS duration_sec
FROM tasks
WHERE created_at > NOW() - INTERVAL '1 hour'
ORDER BY created_at DESC;"
agent_id | status | created_at | duration_sec
---------------------+-----------+---------------------------+-------------
subagent-test | completed | 2026-08-10 14:45:00+00 | 180
subagent-build | completed | 2026-08-10 14:35:00+00 | 420
subagent-research | completed | 2026-08-10 14:20:00+00 | 900
(3 rows)--rm）或在使用后由编排者清理。遗留容器会泄漏内存和磁盘。context 字符串中传递 API 密钥——它们最终会进入 LLM 上下文和会话日志。改为通过 Docker 的 -e 标志使用环境变量。delegate_task(tasks=[...])）原生处理并行——PostgreSQL 用于持久状态，而非消息队列使用 Docker 隔离子 Agent 的多 Agent 编排，将 Hermes Agent 从单工作器工具转变为并行执行引擎。上述模式——容器隔离、PostgreSQL 协调和基于 Git 的产出物交换——是生产级多 Agent 系统的基础。每一条命令都在真实硬件上经过验证。