agent-relay 1.0.7 → 1.0.9

package/docs/COMPETITIVE_ANALYSIS.md

@@ -0,0 +1,897 @@
+# Multi-Agent Orchestration: Competitive Analysis
+
+*Generated: December 2025*
+
+## Executive Summary
+
+This analysis evaluates 16 multi-agent orchestration tools against agent-relay. The key finding is that **most tools don't provide true real-time agent-to-agent communication** - they use sub-agent delegation, file-based polling, or shared databases instead.
+
+**agent-relay's differentiators:**
+- Real-time messaging via Unix Domain Socket (sub-5ms latency)
+- Direct peer-to-peer agent communication (not just orchestrator-worker)
+- No API key required (wraps existing CLI tools)
+- Simple `->relay:` pattern for messaging
+
+---
+
+## Quick Comparison Matrix
+
+| Tool | API Key? | Communication Type | Mechanism | Real-time? | Memory |
+|------|----------|-------------------|-----------|------------|--------|
+| **agent-relay** | No | Direct P2P | Unix socket | Yes | SQLite (pluggable) |
+| Multiagent Chat | No | File + PTY push | Outbox → PTY write | Partial | JSONL chat log |
+| AI Maestro | No (OAuth) | File + WebSocket | File-based queues | Partial | Built-in (code graph) |
+| Toad | Yes | Protocol-based | ACP/A2A protocol | No | Minimal |
+| Oh-My-OpenCode | Yes (multi) | Hierarchical | Sub-agent delegation | No | Context-based |
+| Auto-Claude | Yes | Isolated | Git worktrees | No | Optional (Graphiti) |
+| Maestro | Yes | Group chat + IPC | Electron IPC | Partial | Ephemeral |
+| ACFS | Yes (multi) | File + HTTP | mcp_agent_mail | No | Hybrid (cm) |
+| Claude-Flow | No | Hive-mind | Message bus | Yes | Built-in (AgentDB) |
+| Vibe Kanban | Yes | Unknown | Undocumented | Unknown | Unknown |
+| AxonFlow | Yes | Centralized | Service mesh | Partial | External (Postgres) |
+| Mimir | Optional | Shared DB | Neo4j graph | No | Built-in (Neo4j) |
+| Claude MPM | No | Orchestrator | Subprocess | No | Pluggable |
+| Multi-MCP | Yes | Parallel LLM | asyncio.gather | N/A | None |
+| Every Code | Yes | Consensus | Racing pattern | Partial | Session-based |
+| Orc | Yes | File-based | Drums directory | No | State files |
+| Pied Piper | Yes | Task-based | Beads labels | No | Beads |
+
+---
+
+## Tier 1: Most Relevant Competitors (Check First)
+
+### 1. Claude-Flow (ruvnet/claude-flow)
+**Most Similar to agent-relay**
+
+**Communication:** Queen-led hive-mind with message bus pattern
+- 19-file coordination system with work-stealing
+- MCP tools for swarm orchestration
+- Circuit breakers and distributed locking
+
+**Key Stats:**
+- 84.8% SWE-Bench solve rate
+- 96x-164x memory query performance boost
+- No API key required (hash-based embeddings)
+
+**Pros:**
+- Sophisticated coordination (scheduling, load balancing, fault tolerance)
+- Built-in memory (AgentDB with HNSW indexing)
+- 25 specialized skills + 9 RL algorithms
+
+**Cons:**
+- Very complex (steep learning curve)
+- Heavy resource requirements
+- Overkill for simple orchestration
+
+**What We Can Learn:**
+- Work-stealing for dynamic load balancing
+- Circuit breaker patterns for fault tolerance
+- Dependency graph for task ordering
+
+**Where We're Stronger:**
+- Simpler to understand and use
+- Lighter weight
+- Direct terminal integration with tmux
+
+---
+
+### 2. Maestro (pedramamini/Maestro)
+**Best Desktop UI**
+
+**Communication:** Group chat with AI moderator + Git worktrees
+- Dual-process sessions (AI agent + terminal)
+- Message queueing while agents busy
+- Electron IPC for internal coordination
+
+**Pros:**
+- Rich desktop UI with three-panel layout
+- Auto Run playbooks for batch processing
+- Mobile access via Cloudflare tunnels
+- Session discovery from existing Claude Code
+
+**Cons:**
+- Desktop-only (requires Electron)
+- No persistent cross-session memory
+- Single-agent per session limitation
+
+**What We Can Learn:**
+- Playbook system for automated task batching
+- Session discovery/import from existing tools
+- QR code + tunneling for mobile access
+
+**Where We're Stronger:**
+- CLI-native (no Electron overhead)
+- True multi-agent in single project
+- Persistent message history
+
+---
+
+### 3. AI Maestro (23blocks-OS/ai-maestro)
+**Best Remote/Multi-Machine**
+
+**Communication:** File-based messaging + WebSocket proxy
+- Priority queues (urgent/high/normal/low)
+- Persistent inbox/outbox per agent
+- CLI scripts for agent-to-agent messaging
+
+**Pros:**
+- Excellent mobile support (Tailscale VPN)
+- Scales to 100+ agents across machines
+- Rich memory (code graph, semantic search)
+- Portable agent export/import
+
+**Cons:**
+- File-based messaging has latency
+- Complex setup (PM2, SSH, tmux)
+- macOS 15+ needs daemon fixes
+
+**What We Can Learn:**
+- Multi-machine support architecture
+- Agent portability (export/import)
+- Code graph visualization
+- Priority-based message queuing
+
+**Where We're Stronger:**
+- Real-time messaging (not file polling)
+- Simpler single-machine setup
+- No PM2/SSH complexity
+
+---
+
+## Tier 2: Interesting Approaches
+
+### 4. Multiagent Chat (appoly/multiagent-chat)
+**Best Planning/Discussion Workflow**
+
+**Communication:** File-based outbox with PTY push delivery
+- Each agent writes to its outbox markdown file
+- Chokidar file watcher detects changes
+- Messages pushed to other agents via `pty.write()` or `stdin.write()`
+- Immutable chat log in JSONL format
+
+**Architecture:**
+- Electron desktop app with xterm terminals
+- node-pty for pseudo-terminal management
+- YAML configuration for agents
+- Two-phase workflow: Planning → Implementation
+
+**Pros:**
+- Nice desktop UI with live xterm terminals
+- Works with existing CLI tools (Claude, Codex)
+- Structured planning workflow with PLAN_FINAL.md output
+- Peer review during implementation phase
+- Message sequence numbering for ordering
+- No API key required (uses local CLI auth)
+
+**Cons:**
+- Electron-only (desktop required)
+- File-based messaging adds latency
+- Node.js v23+ not supported (native module issues)
+- Limited to discussion/planning workflow
+- No persistent memory across sessions
+- Push-based but not true real-time socket
+
+**Technical Details:**
+```yaml
+agents:
+  - name: "Claude"
+    command: "claude"
+    args: ['--dangerously-skip-permissions']
+    use_pty: true
+```
+
+**What We Can Learn:**
+- Structured planning workflow before implementation
+- Peer review patterns for agent collaboration
+- xterm terminal embedding for agent visibility
+- Message sequence numbering for ordering
+
+**Where We're Stronger:**
+- True real-time Unix socket (<5ms vs file I/O latency)
+- CLI-native (no Electron overhead)
+- Direct P2P messaging (not file-mediated)
+- Works with Node.js v23+
+- More flexible use cases (not just planning)
+
+---
+
+### 5. Mimir (orneryd/Mimir)
+**Best Memory System**
+
+**Communication:** Indirect via shared Neo4j graph database
+- Multi-agent locking mechanism
+- 13 MCP tools for memory operations
+- No direct messaging (async via DB)
+
+**Pros:**
+- Persistent knowledge graph
+- Semantic search with embeddings
+- PM/Worker/QC workflow patterns
+- Can run offline with Ollama
+
+**Cons:**
+- Complex infrastructure (Docker + Neo4j)
+- No real-time direct messaging
+- Resource intensive
+
+**What We Can Learn:**
+- Knowledge graph for persistent context
+- Multi-agent locking patterns
+- Role-specific context filtering
+
+**Where We're Stronger:**
+- Real-time communication
+- Simpler setup
+- Direct agent-to-agent messaging
+
+---
+
+### 5. ACFS (Dicklesworthstone/agentic_coding_flywheel_setup)
+**Best Developer Environment**
+
+**Communication:** MCP HTTP server (mcp_agent_mail) + file-based state
+- 8-tool "Dicklesworthstone stack"
+- Named tmux session management
+- Procedural memory across sessions
+
+**Pros:**
+- VPS-optimized with 30-min setup
+- Comprehensive dev environment (30+ tools)
+- Persistent learning via cass-memory
+- Safety mechanisms (two-person rule)
+
+**Cons:**
+- VPS-only (not for local dev)
+- Asynchronous (not real-time)
+- Complex 11-category install
+
+**What We Can Learn:**
+- mcp_agent_mail patterns for messaging
+- Procedural memory (cm) for learned patterns
+- Safety mechanisms for dangerous commands
+
+**Where We're Stronger:**
+- Works locally (not VPS-only)
+- Real-time sync
+- Simpler setup
+
+---
+
+### 6. Orc (bsmith24/orc)
+**Simplest Two-Agent System**
+
+**Communication:** File-based "drums" directory
+- `pm_out.txt` / `dev_out.txt` for responses
+- `pm_in.txt` / `dev_in.txt` for input
+- Approval tracking files
+
+**Pros:**
+- Dead simple architecture
+- Clear Taskmaster/Builder separation
+- Session persistence via state files
+- Works with existing Claude CLI
+
+**Cons:**
+- Only two agents
+- No real-time updates
+- Manual file-watching
+
+**What We Can Learn:**
+- Simple file-based approach can work
+- Clear role separation patterns
+- Session state persistence
+
+**Where We're Stronger:**
+- Unlimited agents
+- Real-time messaging
+- Automatic message routing
+
+---
+
+### 7. Pied Piper (sathish316/pied-piper)
+**Best Task-Centric Approach**
+
+**Communication:** Beads-based task labels
+- Label-based routing (`@ready-for-hld`, etc.)
+- Human-in-loop approvals
+- YAML playbook configurations
+
+**Pros:**
+- Integrates with Beads for task tracking
+- Multi-model ensembles
+- Full audit trails
+- Customizable team configs
+
+**Cons:**
+- Not real-time communication
+- Task-based (not message-based)
+- Requires Go build
+
+**What We Can Learn:**
+- Beads integration patterns (we already use this!)
+- Playbook YAML structure for teams
+- Audit trail approaches
+
+**Where We're Stronger:**
+- Real-time messaging vs task handoffs
+- Direct communication vs label routing
+- Simpler npm install
+
+---
+
+## Tier 3: Different Focus
+
+### 8. Oh-My-OpenCode
+**Best Multi-Model Strategy**
+
+Uses hierarchical sub-agents (Sisyphus → Oracle → Frontend Engineer → Librarian) with different models for different roles. $24k token investment in refinement.
+
+**Best for:** Sophisticated multi-model workflows
+**Not competing on:** Direct agent communication
+
+---
+
+### 9. Auto-Claude
+**Best Parallel Isolation**
+
+Up to 12 agents in isolated git worktrees. AI-assisted conflict resolution during merge. Optional Graphiti memory layer.
+
+**Best for:** Autonomous parallel development
+**Not competing on:** Agent collaboration
+
+---
+
+### 10. AxonFlow
+**Best Enterprise Governance**
+
+Policy-first with PII detection, SQL injection blocking. Multi-model routing based on cost/compliance.
+
+**Best for:** Regulated environments
+**Not competing on:** Developer workflow
+
+---
+
+### 11. Every Code (just-every/code)
+**Best Consensus Approach**
+
+Multiple agents compete or collaborate via `/plan` (consensus) and `/solve` (fastest wins).
+
+**Best for:** Quick task completion
+**Not competing on:** Persistent collaboration
+
+---
+
+### 12. Toad
+**Best Terminal UI**
+
+Beautiful TUI for 12+ different AI agents. Uses Agent Client Protocol (ACP) merged with Google's A2A.
+
+**Best for:** Unified terminal experience
+**Not competing on:** Multi-agent orchestration
+
+---
+
+### 13. Vibe Kanban
+**Best Visual Workflow**
+
+Kanban-style task management with agent switching. Rust + TypeScript. 6.7k stars.
+
+**Best for:** Visual project management
+**Not competing on:** Agent communication (undocumented)
+
+---
+
+### 14. Claude MPM
+**Best Agent Library**
+
+47+ specialized agents from curated repos. Intelligent routing via orchestrator.
+
+**Best for:** Finding the right agent for a task
+**Not competing on:** Direct agent messaging
+
+---
+
+### 15. Multi-MCP
+**Not True Multi-Agent**
+
+Just parallel LLM calls via asyncio.gather(). Useful for consensus but agents don't communicate.
+
+---
+
+## Communication Mechanism Comparison
+
+### Real-Time Direct (Like agent-relay)
+| Tool | Mechanism | Latency |
+|------|-----------|---------|
+| agent-relay | Unix Domain Socket | <5ms |
+| Claude-Flow | Message Bus | Low |
+| Maestro | Electron IPC | Low |
+
+### File-Based Async
+| Tool | Mechanism | Latency |
+|------|-----------|---------|
+| Multiagent Chat | Outbox → PTY push | ~50-100ms |
+| AI Maestro | Priority queues | ~100ms+ |
+| ACFS | mcp_agent_mail | ~100ms+ |
+| Orc | Drums directory | Polling |
+
+### Sub-Agent/Delegation
+| Tool | Pattern |
+|------|---------|
+| Oh-My-OpenCode | Hierarchical (Sisyphus model) |
+| Claude MPM | Orchestrator → specialists |
+| Auto-Claude | Isolated worktrees |
+
+### Shared State
+| Tool | Mechanism |
+|------|-----------|
+| Mimir | Neo4j graph database |
+| Pied Piper | Beads labels |
+| AxonFlow | PostgreSQL + Redis |
+
+---
+
+## Memory Architecture Comparison
+
+### Built-In Sophisticated
+- **Claude-Flow:** AgentDB + 4-layer architecture + HNSW indexing
+- **Mimir:** Neo4j knowledge graph + semantic embeddings
+- **AI Maestro:** Code graph + conversation indexing
+
+### Component/Pluggable
+- **agent-relay:** SQLite (default) or memory adapter
+- **ACFS:** cass-memory for procedural patterns
+- **Auto-Claude:** Optional Graphiti layer
+
+### Minimal/Session-Only
+- **Maestro:** Ephemeral (context isolation focus)
+- **Claude MPM:** Resume logs only
+- **Multi-MCP:** Conversation threading
+
+---
+
+## Remote/Mobile Access
+
+| Tier | Tools |
+|------|-------|
+| **Excellent** | AI Maestro (Tailscale VPN, mobile UI) |
+| **Good** | Maestro (Cloudflare tunnels), Claude-Flow (Flow Nexus cloud) |
+| **Partial** | Vibe Kanban (SSH), AxonFlow (SDKs), Mimir (Docker web) |
+| **None** | Claude MPM, Oh-My-OpenCode, Auto-Claude, Orc |
+
+agent-relay: **Partial** (dashboard at localhost:3888, could add remote tunneling)
+
+---
+
+## Recommended Priority for Investigation
+
+### Must Study (High Priority)
+1. **Claude-Flow** - Most sophisticated coordination, similar goals
+2. **Maestro** - Best UX patterns, mobile access approach
+3. **AI Maestro** - Multi-machine scaling, agent portability
+
+### Should Study (Medium Priority)
+4. **Multiagent Chat** - Planning workflow, peer review patterns
+5. **Mimir** - Memory/knowledge graph patterns
+6. **ACFS** - mcp_agent_mail patterns, procedural memory
+7. **Pied Piper** - Already uses Beads, complementary
+
+### Worth Knowing (Low Priority)
+8. **Orc** - Simple file-based reference
+9. **Every Code** - Consensus patterns
+10. **Oh-My-OpenCode** - Multi-model strategies
+
+---
+
+## What agent-relay Should Learn
+
+### From Claude-Flow
+- [ ] Work-stealing for load balancing
+- [ ] Circuit breaker patterns
+- [ ] Dependency graph for task ordering
+- [ ] HNSW indexing for fast memory queries
+
+### From Maestro
+- [ ] Session discovery from existing Claude Code
+- [ ] Playbook system for automated batching
+- [ ] Cloudflare tunneling for remote access
+- [ ] QR code for easy mobile connection
+
+### From AI Maestro
+- [ ] Multi-machine agent support
+- [ ] Agent portability (export/import)
+- [ ] Priority-based message queuing
+- [ ] Code graph visualization
+
+### From Mimir
+- [ ] Knowledge graph for persistent context
+- [ ] Multi-agent locking mechanisms
+- [ ] Role-specific context filtering
+
+### From ACFS
+- [ ] Procedural memory for learned patterns
+- [ ] Safety mechanisms (two-person rule)
+- [ ] Named tmux session management patterns
+
+### From Multiagent Chat
+- [ ] Structured planning phase before implementation
+- [ ] Peer review workflow for agent collaboration
+- [ ] xterm terminal embedding in dashboard
+- [ ] Message sequence numbering for ordering
+
+---
+
+## Where agent-relay is Stronger
+
+| vs Tool | Our Advantage |
+|---------|---------------|
+| Most competitors | True real-time messaging (<5ms) |
+| File-based (AI Maestro, Orc, ACFS, Multiagent Chat) | No polling, instant delivery |
+| Sub-agent (Claude MPM, Oh-My-OpenCode) | Direct P2P, not orchestrator bottleneck |
+| Desktop (Maestro, Multiagent Chat) | CLI-native, no Electron overhead |
+| Complex (Claude-Flow) | Simple to understand and use |
+| VPS-only (ACFS) | Works locally |
+| Heavy (Mimir) | Lightweight, no Neo4j required |
+| Multiagent Chat | Node.js v23+ support, flexible use cases |
+
+---
+
+## Gaps to Address
+
+### High Priority
+1. **Remote/Mobile Access** - Most competitors have this, we don't
+2. **Multi-Machine Support** - AI Maestro does this well
+3. **Persistent Memory** - Claude-Flow and Mimir have sophisticated approaches
+
+### Medium Priority
+4. **Playbooks/Automation** - Maestro's batch processing approach
+5. **Session Discovery** - Import existing Claude Code sessions
+6. **Priority Queuing** - AI Maestro's urgent/high/normal/low
+
+### Nice to Have
+7. **Work-Stealing** - From Claude-Flow for load balancing
+8. **Circuit Breakers** - Fault tolerance patterns
+9. **Agent Portability** - Export/import agent state
+
+---
+
+## Solution Rankings by Use Case
+
+### Overall Tier List
+
+| Tier | Tools | Why |
+|------|-------|-----|
+| **S-Tier** | Claude-Flow | Most complete feature set, proven SWE-Bench results |
+| **A-Tier** | agent-relay, Maestro, AI Maestro | Strong in specific areas, production-viable |
+| **B-Tier** | Multiagent Chat, Mimir, ACFS | Good for specific workflows, some limitations |
+| **C-Tier** | Orc, Pied Piper, Every Code | Niche use cases or early stage |
+| **D-Tier** | Multi-MCP, Toad | Not true multi-agent or limited scope |
+
+---
+
+### Best Solution by Use Case
+
+#### 1. Real-Time Agent Communication
+*Need: Agents talking to each other with minimal latency*
+
+| Rank | Tool | Latency | Notes |
+|------|------|---------|-------|
+| 🥇 | **agent-relay** | <5ms | Unix socket, direct P2P |
+| 🥈 | Claude-Flow | Low | Message bus, more overhead |
+| 🥉 | Maestro | Low | Electron IPC, desktop only |
+| 4th | Multiagent Chat | ~50-100ms | File → PTY push |
+| 5th | AI Maestro | ~100ms+ | File-based queues |
+
+**Winner: agent-relay** - Fastest, simplest real-time messaging
+
+---
+
+#### 2. Easiest Setup / Getting Started
+*Need: Minimal configuration, works out of the box*
+
+| Rank | Tool | Setup Time | Requirements |
+|------|------|------------|--------------|
+| 🥇 | **agent-relay** | ~1 min | npm install, no config needed |
+| 🥈 | Orc | ~2 min | Simple file-based, 2 agents only |
+| 🥉 | Multiagent Chat | ~5 min | npm install, YAML config |
+| 4th | Maestro | ~10 min | Electron install, desktop app |
+| 5th | Claude-Flow | ~15 min | Complex configuration |
+| 6th | Mimir | ~30 min | Docker + Neo4j setup |
+| 7th | ACFS | ~30 min | VPS + 11-category install |
+
+**Winner: agent-relay** - `npm i -g agent-relay && agent-relay up`
+
+---
+
+#### 3. Rich Desktop UI / Visualization
+*Need: Visual interface for monitoring agents*
+
+| Rank | Tool | UI Type | Features |
+|------|------|---------|----------|
+| 🥇 | **Maestro** | Electron | Three-panel layout, session discovery |
+| 🥈 | **Multiagent Chat** | Electron | xterm terminals, live chat |
+| 🥉 | Vibe Kanban | Web | Kanban boards (6.7k stars) |
+| 4th | agent-relay | Web | Dashboard at localhost:3888 |
+| 5th | AI Maestro | Web | Basic status dashboard |
+| 6th | Claude-Flow | CLI | Flow Nexus (limited) |
+
+**Winner: Maestro** - Best desktop experience with mobile access
+
+---
+
+#### 4. Enterprise / Production Scale
+*Need: Governance, compliance, fault tolerance*
+
+| Rank | Tool | Governance | Scale | Fault Tolerance |
+|------|------|------------|-------|-----------------|
+| 🥇 | **AxonFlow** | PII detection, policy-first | High | Service mesh |
+| 🥈 | **Claude-Flow** | Circuit breakers | High | Work-stealing, locking |
+| 🥉 | AI Maestro | Basic | 100+ agents | PM2 process management |
+| 4th | agent-relay | None | Medium | SQLite persistence |
+| 5th | Mimir | Multi-agent locking | Medium | Neo4j reliability |
+
+**Winner: AxonFlow** - Built for regulated environments
+
+---
+
+#### 5. Multi-Machine / Distributed Agents
+*Need: Agents running on different machines*
+
+| Rank | Tool | Multi-Machine | Mobile Access |
+|------|------|---------------|---------------|
+| 🥇 | **AI Maestro** | Native (SSH, PM2) | Tailscale VPN |
+| 🥈 | **Maestro** | Cloudflare tunnels | QR code pairing |
+| 🥉 | Claude-Flow | Flow Nexus cloud | Partial |
+| 4th | ACFS | VPS-native | SSH |
+| 5th | agent-relay | Not yet | Dashboard only |
+
+**Winner: AI Maestro** - Purpose-built for distributed teams
+
+---
+
+#### 6. Persistent Memory / Knowledge Graph
+*Need: Agents remembering context across sessions*
+
+| Rank | Tool | Memory Type | Sophistication |
+|------|------|-------------|----------------|
+| 🥇 | **Mimir** | Neo4j knowledge graph | Semantic embeddings |
+| 🥈 | **Claude-Flow** | AgentDB + HNSW | 4-layer architecture |
+| 🥉 | AI Maestro | Code graph + indexing | Conversation memory |
+| 4th | ACFS | cass-memory | Procedural patterns |
+| 5th | agent-relay | SQLite | Message history only |
+| 6th | Multiagent Chat | JSONL | Chat log only |
+
+**Winner: Mimir** - Full knowledge graph with semantic search
+
+---
+
+#### 7. Planning & Structured Workflows
+*Need: Formal planning before implementation*
+
+| Rank | Tool | Planning Features |
+|------|------|-------------------|
+| 🥇 | **Multiagent Chat** | Two-phase workflow, PLAN_FINAL.md, peer review |
+| 🥈 | **Pied Piper** | Beads integration, playbooks, audit trails |
+| 🥉 | **Maestro** | Auto Run playbooks, batch processing |
+| 4th | Oh-My-OpenCode | Hierarchical refinement ($24k token investment) |
+| 5th | agent-relay | No built-in workflow |
+
+**Winner: Multiagent Chat** - Purpose-built for planning discussions
+
+---
+
+#### 8. Multi-Model Orchestration
+*Need: Different AI models for different tasks*
+
+| Rank | Tool | Models Supported | Routing |
+|------|------|------------------|---------|
+| 🥇 | **Oh-My-OpenCode** | Multiple (Sisyphus hierarchy) | Role-based |
+| 🥈 | **AxonFlow** | Multiple | Cost/compliance routing |
+| 🥉 | **Toad** | 12+ agents | Unified TUI |
+| 4th | Every Code | Multiple | Consensus/racing |
+| 5th | agent-relay | Any CLI | No routing (user choice) |
+
+**Winner: Oh-My-OpenCode** - Sophisticated multi-model workflows
+
+---
+
+#### 9. CLI-Native / Lightweight
+*Need: Terminal-first, minimal resource usage*
+
+| Rank | Tool | Runtime | Memory Footprint |
+|------|------|---------|------------------|
+| 🥇 | **agent-relay** | Node.js CLI | ~50MB |
+| 🥈 | **Orc** | Shell scripts | ~10MB |
+| 🥉 | Claude-Flow | Node.js | ~200MB |
+| 4th | ACFS | Node.js + tools | ~300MB |
+| 5th | Maestro | Electron | ~500MB+ |
+| 6th | Mimir | Docker + Neo4j | ~2GB+ |
+
+**Winner: agent-relay** - Lightest full-featured solution
+
+---
+
+#### 10. Parallel Development / Isolation
+*Need: Multiple agents working on same codebase without conflicts*
+
+| Rank | Tool | Isolation Method |
+|------|------|------------------|
+| 🥇 | **Auto-Claude** | Git worktrees (up to 12 agents) |
+| 🥈 | **Maestro** | Session isolation per worktree |
+| 🥉 | agent-relay | tmux sessions (shared codebase) |
+| 4th | Every Code | Racing pattern |
+
+**Winner: Auto-Claude** - Purpose-built for parallel isolation
+
+---
+
+### Quick Decision Matrix
+
+| If you need... | Use this |
+|----------------|----------|
+| **Fastest setup** | agent-relay |
+| **Real-time chat between agents** | agent-relay |
+| **Beautiful desktop UI** | Maestro or Multiagent Chat |
+| **Agents on multiple machines** | AI Maestro |
+| **Enterprise governance** | AxonFlow |
+| **Persistent knowledge graph** | Mimir |
+| **Structured planning workflow** | Multiagent Chat |
+| **Different models for different tasks** | Oh-My-OpenCode |
+| **Lightest resource usage** | agent-relay or Orc |
+| **Parallel isolated development** | Auto-Claude |
+| **Most features overall** | Claude-Flow |
+
+---
+
+### Where agent-relay Wins
+
+| Use Case | Why agent-relay |
+|----------|-----------------|
+| **Quick prototyping** | 1-minute setup, immediate messaging |
+| **Real-time collaboration** | <5ms latency, direct P2P |
+| **CLI workflows** | No Electron, integrates with tmux |
+| **Simple multi-agent** | Just works with existing Claude/Codex |
+| **Resource-constrained** | Lightweight, no Docker/Neo4j |
+
+### Where agent-relay Should Defer
+
+| Use Case | Better Choice | Why |
+|----------|---------------|-----|
+| Enterprise compliance | AxonFlow | Policy-first, PII detection |
+| Visual workflows | Maestro | Rich desktop UI |
+| Multi-machine | AI Maestro | Native distributed support |
+| Knowledge persistence | Mimir | Neo4j graph database |
+| Planning discussions | Multiagent Chat | Structured workflow |
+| Parallel isolation | Auto-Claude | Git worktree isolation |
+
+---
+
+## agent-relay as a Composable Layer
+
+### The Integration Advantage
+
+Most competitors try to be **complete solutions** - handling communication, memory, UI, workflows, and orchestration. agent-relay takes a different approach: **do one thing exceptionally well** (real-time messaging) and integrate with best-of-breed tools for everything else.
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Your Agent System                        │
+├─────────────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
+│  │   Mimir     │  │  Maestro    │  │  Pied Piper │         │
+│  │  (Memory)   │  │    (UI)     │  │ (Workflows) │         │
+│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘         │
+│         │                │                │                 │
+│         └────────────────┼────────────────┘                 │
+│                          │                                  │
+│                ┌─────────▼─────────┐                        │
+│                │   agent-relay     │                        │
+│                │  (Real-time P2P)  │                        │
+│                │     <5ms          │                        │
+│                └─────────┬─────────┘                        │
+│                          │                                  │
+│         ┌────────────────┼────────────────┐                 │
+│         │                │                │                 │
+│    ┌────▼────┐     ┌────▼────┐     ┌────▼────┐             │
+│    │ Claude  │     │  Codex  │     │  Gemini │             │
+│    └─────────┘     └─────────┘     └─────────┘             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Composition Examples
+
+| Combine agent-relay with... | You get... |
+|-----------------------------|------------|
+| **Mimir** | Real-time chat + persistent knowledge graph |
+| **Maestro** | Real-time messaging + rich desktop UI |
+| **Beads/Pied Piper** | Real-time chat + dependency-aware task tracking |
+| **Auto-Claude** | Real-time coordination + isolated git worktrees |
+| **AxonFlow** | Real-time P2P + enterprise governance layer |
+| **ACFS** | Real-time sync + procedural memory |
+
+### Why This Matters
+
+**Monolithic solutions** (Claude-Flow, AI Maestro):
+- ✅ Everything works together out of the box
+- ❌ Locked into their choices (Neo4j, Electron, etc.)
+- ❌ Hard to swap components
+- ❌ Heavier resource usage
+
+**Composable approach** (agent-relay + X):
+- ✅ Best tool for each job
+- ✅ Swap components as better ones emerge
+- ✅ Lighter base footprint
+- ✅ Works with existing infrastructure
+- ❌ Requires integration work
+
+### Potential Integrations Roadmap
+
+| Integration | Benefit | Complexity |
+|-------------|---------|------------|
+| **Mimir adapter** | Add Neo4j memory to agent-relay | Medium |
+| **Maestro bridge** | Use Maestro UI with relay messaging | Medium |
+| **Beads sync** | Auto-create Beads issues from agent messages | Low (already partial) |
+| **Cloudflare tunnel** | Remote access like Maestro | Low |
+| **MCP server** | Expose relay as MCP tools | Low |
+
+### Revised Tier List (as Integration Layer)
+
+When considering agent-relay as a **messaging layer** rather than complete solution:
+
+| Scenario | Tier |
+|----------|------|
+| Standalone simple multi-agent | **A-Tier** |
+| + Mimir for memory | **S-Tier** (best of both) |
+| + Maestro UI | **S-Tier** (best of both) |
+| + Beads for workflows | **A-Tier** (already works) |
+| Enterprise (+ AxonFlow governance) | **A-Tier** |
+
+### The Unix Philosophy
+
+agent-relay follows the Unix philosophy:
+- **Do one thing well**: Real-time agent messaging
+- **Work with others**: Simple patterns (`->relay:`), standard I/O
+- **Text streams**: Messages are just text, easy to parse/transform
+- **Composability**: Pipe into other tools, wrap other CLIs
+
+This is why agent-relay can potentially **beat Claude-Flow** in a composed system - you get real-time messaging without the 19-file coordination complexity, then add only the features you actually need.
+
+---
+
+## Conclusion
+
+agent-relay occupies a unique position: **the real-time messaging layer for multi-agent systems**.
+
+### Standalone Value
+- Simple, real-time, direct agent-to-agent communication
+- No API keys required (wraps existing CLI tools)
+- <5ms latency via Unix Domain Socket
+- 1-minute setup
+
+### Composable Value
+- **Messaging primitive** that integrates with best-of-breed tools
+- Combine with Mimir (memory), Maestro (UI), Beads (workflows)
+- Unix philosophy: do one thing well, compose with others
+- Lighter than monolithic solutions
+
+### Competitive Position
+
+| Approach | Example | agent-relay's Role |
+|----------|---------|-------------------|
+| Monolithic | Claude-Flow | Alternative (simpler) |
+| File-based | AI Maestro, Orc | Replacement (faster) |
+| Desktop-only | Maestro, Multiagent Chat | Complement (CLI layer) |
+| Memory-focused | Mimir | Complement (add messaging) |
+| Workflow-focused | Pied Piper | Complement (add real-time) |
+
+### Strategic Direction
+
+**Short-term:** Best standalone real-time messaging for simple multi-agent
+**Long-term:** The messaging backbone that other tools integrate with
+
+**Key opportunities:**
+1. **MCP server** - Expose relay as MCP tools for broader integration
+2. **Cloudflare tunnel** - Remote access like Maestro
+3. **Mimir adapter** - Optional persistent memory
+4. **Maestro bridge** - Use their UI with our messaging
+
+**Biggest threat:** Claude-Flow has similar real-time capabilities with more features, but is significantly more complex. The composable approach may win in the long run as developers prefer best-of-breed components over monolithic solutions.