agent-relay 1.2.0 → 1.3.0

package/docs/competitive/OVERVIEW.md

@@ -1,898 +0,0 @@
-# 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) |
-| Tmux-Orchestrator | No | Hierarchical | tmux send-keys | No (~500ms) | Git commits |
-| 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.