Agent Coordination Patterns

Source Excerpt

Overview

The retired internal project Quad (Julius, Cypher, Reacher, Octavius) uses several coordination patterns for distributed work across machines. This document captures the patterns that have been tested and validated.

Patterns

1. SSH-Bridged ACP Delegation

Use case: Send a task to a remote agent via Hermes Agent's delegate_task with SSH routing.

How it works:

• Julius calls delegate_task with a route pointing to remote machine
• SSH tunnel bridges the ACP (Agent Communication Protocol) connection
• Remote agent executes the task independently
• Results returned via the SSH channel

Limitations:

• delegate_task BLOCKS the calling agent until completion
• Not suitable for fire-and-forget work
• Context window limits mean remote agents get no conversation history

2. Concurrent Work via Launch Scripts

Use case: Dispatch independent work to multiple agents simultaneously.

How it works:

• Julius writes task packets (markdown instructions) for each agent
• SCP packets + session files to remote machines
• Launch via bash scripts: nohup python3 run_agent.py --prompt-file packet.md
• Agents work independently, write results to disk
• Julius collects results later via rsync/SCP

Advantages:

• True parallel execution
• No blocking of calling agent
• Each agent gets full context window for its task

Pitfalls:

• Cypher hangs frequently (0% CPU, 0 bytes stdout)
• Reacher wiki path differs from others
• Octavius output path is /home/jared596/wiki/wiki/ not ~/ClarkFarmingCompany/

2a. concurrent-work.py Deterministic Helper (Validated 2026-05-28)

A deterministic Python helper script (~/.hermes/scripts/concurrent-work.py) was validated on 2026-05-28 (Session 20260528_210449_333e48).

What it does: Turns a structured JSON manifest into a durable /tmp/cfc run directory with task packets, launch scripts, poll commands, and status reports. Default mode is dry-run/report-only; actual remote SSH/SCP execution requires --apply.

Validation results:

• Script compiled clean (python3 -m py_compile passed)
• Generated correct task packets, launch.sh scripts, and commands.json for Octavius and Reacher
• Proper machine-specific paths (Octavius: /home/jared596, Reacher: /Users/reacher)
• Correct Hermes binary paths per machine
• No remote agents were launched — dry-run only

Status: Validated and ready for use. Reduces manual concurrent_work overhead by automating packet generation and launch script creation.

3. Cron-Based Coordination

Use case: Recurring tasks that don't require real-time coordination.

How it works:

• Julius creates cron jobs on each machine
• Jobs run on schedule, deliver results to specified channels
• No real-time coordination needed

Examples:

• Daily wiki lint (Julius)
• Daily standup (Julius)
• Industrial knowledge curation (Julius)
• Fleet updates (Julius)

4. File-Based Communication

Use case: Asynchronous communication between agents.

How it works:

• Agents write to shared directories (/artifacts/, /messages/)
• Other agents poll for new files
• Structured formats (JSON, markdown) for machine readability

Status:

• /artifacts/ used for briefs, policies, decisions
• /messages/ used for escalations and blockers
• Not yet fully implemented across all machines

Recommendations

• For parallel work: Use concurrent work via launch scripts
• For simple queries: Use SSH-bridged ACP delegation
• For recurring tasks: Use cron jobs
• For async communication: Use file-based messaging

Status

All patterns tested and documented. Concurrent work via launch scripts is the most reliable for complex tasks.