Myelix Agents vs The Agent Ecosystem — Comprehensive Technical Comparison

1. Feature Matrices

1.1 Core Architecture & Isolation

Feature	Myelix Agents	Cursor / Windsurf	Warp	Codex / Claude Code	Aider / Hermes	Factory.ai / Devin / OpenHands
Massive Concurrency (BEAM/OTP)	✅	❌	❌	❌	❌	❌
Concurrent Git Worktree Isolation	✅	❌	✅ (code feature)	❌	❌	❌
Docker / Container Sandboxing	❌	❌	✅ (cloud agents)	❌	❌	✅
PTY OS Sandboxing (bwrap/pledge)	✅	❌	❌	❌	❌	❌
Host Directory Mutation (In-place)	❌	✅	✅ (local)	✅	✅	❌
Self-hosting / On-premise	✅	❌	✅ (Enterprise)	❌	✅	✅ (OpenHands)
Elixir OTP Supervision Trees	✅	❌	❌	❌	❌	❌
Open Source (Client/Core)	❌	❌	✅ (client AGPL)	✅ (Codex)	✅	✅ (OpenHands)

1.2 Code Intelligence Engine

Feature	Myelix Agents (Synapse)	Cursor / Windsurf	Warp	Codex / Claude Code	Aider	Factory.ai
Native AST Code-Knowledge Graph (50+ langs)	✅	❌	❌	❌	❌	❌
Semantic RAG (Vector Embeddings)	✅ (sqlite_vec KNN)	✅	✅	❌	❌	✅
BM25F Keyword Search	✅	✅	❌	❌	❌	❌
Persistent Cross-Session Learning Cache	✅ (ETS + SQLite)	❌	✅ (Agent Memory, preview)	❌	❌	❌
Tree-sitter Parsing	❌	✅	❌	❌	✅ (repo maps)	❌
Caller / Callee Graph Traversal	✅	❌	❌	❌	❌	❌
Change Blast-Radius Analysis	✅	❌	❌	❌	❌	❌
Staged Indexing (quick_pass + deep)	✅	❌	❌	❌	❌	❌
Multi-repo Cross-Codebase Context	✅	❌	✅	❌	❌	❌

1.3 Execution, Verification & Safety

Feature	Myelix Agents	Cursor / Windsurf	Warp	Codex / Claude Code	Aider	Factory.ai / Devin
Multi-Stage Satisfaction Evaluator (5 gates)	✅	❌	❌	❌	❌	❌
Elixir AST CommandPolicy Filtering	✅	❌	❌	❌	❌	❌
Automated Lint / Test-on-Write Loop	✅	❌	❌	✅ (Aider --auto-test)	✅	✅
Computer Use (GUI Automation)	❌	❌	✅ (cloud only)	❌	❌	✅ (Devin)
Command Allowlist / Denylist	✅	❌	✅	❌	❌	❌
Human Approval Gating	✅	✅	✅	✅	✅	✅
RLHF / Critic Self-Improvement (NxCritic)	✅	❌	❌	❌	❌	❌
Trajectory Labelling (Reward Model)	✅	❌	❌	❌	❌	❌
Mistake Signature Violation Detection	✅	❌	❌	❌	❌	❌
Fuzzy Diff Patcher	✅	❌	❌	❌	❌	❌

1.4 Multi-Agent Orchestration & Prompt Economics

Feature	Myelix Agents	Cursor / Windsurf	Warp	Claude Code	Factory.ai	Warp Factories
Native PM / Kanban Task Decomposition	✅	❌	❌	❌	❌	✅ (Foreman model)
Spawning Concurrent Sub-agents (OTP)	✅	❌	✅ (cloud)	❌	❌	✅
Parent / Child Agent Hierarchy	✅	❌	✅	❌	❌	✅
3-Tier Prefix Caching (Stable/Context/Volatile)	✅	❌	❌	❌	❌	❌
Multi-Agent State Persistence	✅	❌	✅	❌	✅	✅
Trigger-based Automation (Slack/GitHub/Linear)	✅ (Slack)	❌	✅	❌	✅	✅
Cron Scheduling	✅	❌	✅	❌	❌	✅
Multi-LLM Model Routing	✅	✅	✅	✅	✅	✅
Session Learnings / Anti-Pattern Memory	✅	❌	❌	❌	❌	❌
Evidence Ledger Tracking	✅	❌	❌	❌	❌	❌
Steer Directives (mid-run correction)	✅	❌	❌	❌	❌	❌
Execution Contract Enforcement	✅	❌	❌	❌	❌	❌

2. Deep Dive: Each Tool

Cursor & Windsurf — IDE Assistants

Myelix wins for autonomous work

Architecture: Cursor is a fork of VS Code; Windsurf is a standalone IDE. Both embed LLMs into the editing surface.

Code Intelligence: Heavy reliance on Tree-sitter for real-time structural parsing within the editor. LSP integration for type inference and semantic highlighting. Remote semantic RAG embeddings for their "Composer" multi-file feature. No persistent call graph, no cross-session learning, and no blast-radius analysis.

Isolation: None. All edits mutate the active host checkout directly. Running two agents simultaneously on the same repo is unsupported and would cause conflicts.

Verdict: Best-in-class for single-developer, interactive pair programming. Completely unsuited for concurrent, autonomous, long-running work.

Warp — Smart Terminal + Automation Platform

Myelix wins on code intelligence

Architecture: GPU-accelerated terminal (Rust + Metal). Warp has evolved into three distinct product layers:

Local Warp Agent — Terminal-native agent running commands in a real PTY with full interactive programme support.
Warp Agent CLI — Same agent running in any terminal via warp command, including over SSH.
Automation Platform (Oz) — Cloud agent platform with triggers, secrets, multi-agent orchestration, and Harnesses (Warp Agent, Claude Code, Codex, Gemini).

Code Intelligence: Warp's Codebase Context is an embeddings-only RAG index of Git-tracked files. It supports .warpindexingignore and cross-repo context. Critically: no call graph, no AST traversal, no BM25F.

Unique Features: Agent Memory (research preview) — persistent cross-session, cross-harness memory shared between Warp Agent, Claude Code, and Codex. Computer Use for cloud agents. SOC 2 compliance with Zero Data Retention.

Verdict: The only competitor that has moved meaningfully into multi-agent orchestration and cloud automation at scale. A genuine competing paradigm via Warp Factories.

Warp Factories — Managed Software Factory Pipeline

Closest architectural competitor

Warp Factories introduces a Foreman→Specialist agent model that routes work through triage, spec, implement, and review stages. This is Warp's closest competitor to Myelix Agents' multi-agent orchestration. See the direct head-to-head comparison below.

Key difference: Cloud containers vs BEAM processes. Each Warp Factory agent requires its own cloud container (~30s cold boot, significant RAM). Each Myelix Agents sub-agent is a lightweight OTP process (~microseconds, negligible RAM).

OpenAI Codex — CLI Agent

Myelix wins on orchestration

Architecture: CLI agent that runs in a sandboxed environment. Uses ~/.codex/config.toml for MCP configuration. Supports shell execution, file editing, and web search.

Isolation: Sandboxed execution per run; not a persistent process. Each session is stateless.

Unique Features: Native integration with Warp's notification system. Warp Agent Memory supports cross-session persistence for Codex when run as a cloud agent.

Compared to Myelix Agents: Codex is a single-agent, single-run tool. No PM layer, no concurrency, no verification gates, no AST graph. A Myelix Agents PM agent could delegate a coding task to Codex as a sub-agent harness.

Claude Code — Anthropic CLI Agent

Myelix wins on orchestration layer

Architecture: CLI REPL installed at ~/.claude/. Uses typed JSON-based MCP config. Works from any shell.

Code Intelligence: No built-in code graph or RAG. Relies on the model's native context window and any MCP tools connected (e.g. Synapse). With Synapse MCP injected, Claude Code gains full AST graph intelligence.

Unique Features: First-class support in Warp (notification plugin, cloud harness, Agent Memory integration). Supports project-level CLAUDE.md instruction files.

Compared to Myelix Agents: Claude Code is Myelix Agents' most direct "comparable CLI experience" — both are terminal-native agentic systems. However, Claude Code has no concurrency, no PM orchestration layer, no BEAM supervision, and no verification gate loop. It is a single-agent tool. Myelix Agents can use Claude Code as one of its available harnesses.

Hermes — CLI Agent (YAML config)

Myelix wins on all dimensions

Architecture: Detected via a YAML config at ~/.hermes/config.yaml. Uses a YAML object-key format for MCP server entries. Terminal-first agent with YAML-based tool configuration.

Compared to Myelix Agents: No publicly available detailed documentation was found. Based on the Synapse launcher integration, Hermes is a CLI agent comparable in scope to Aider or Codex — single-agent, no orchestration.

OpenClaw — Community CLI Agent

Myelix wins on all dimensions

Architecture: Detected via ~/.openclaw/mcp.json. Standard JSON MCP config format. Community CLI agent compatible with the MCP standard.

Compared to Myelix Agents: Limited public documentation. Based on the MCP config integration, OpenClaw is a single-agent tool. No orchestration, no code graph.

Aider — Open-Source CLI REPL

Aider wins on simplicity & composability

Architecture: Open-source CLI REPL. Writes code diffs directly to the active git repo. Uses Tree-sitter to generate repository maps — structured summaries of the codebase's key symbols passed to the LLM as context.

Unique Features:

--auto-test flag runs the test suite after every edit and feeds failures back to the agent
--architect mode separates high-level planning from code editing into two separate LLM calls
Supports 100+ LLMs via LiteLLM — extremely low-overhead, highly composable
Produces clean git commits for each change

Weaknesses: Single-threaded execution only. Two Aider sessions in the same repo simultaneously will cause git merge conflicts. No concurrency model, no verification gates, no blast-radius analysis.

Compared to Myelix Agents: Aider is the "swiss army knife" for a single developer's rapid file patching. Myelix Agents operates an entirely different scope — orchestrating multiple agents doing parallel work with verification gates preventing merges until tests pass.

Refact.ai — Self-Hosted IDE Plugin + Agent

Refact wins on fine-tuning & privacy

Architecture: Open-source, self-hostable AI coding agent. Runs as a plugin in VS Code, JetBrains, Neovim, and Emacs (plus a web UI). The server component runs locally or on a private server.

Unique Features:

Fine-tuning support: Refact can be fine-tuned on a team's private codebase to produce code matching the team's patterns and style — unique in the ecosystem
On-premise deployment: Full air-gapped deployment with a self-hosted model server
MCP support for extending agents with external tools

Compared to Myelix Agents: Refact's USP is fine-tuning and on-premise privacy. Myelix Agents' USP is concurrent multi-agent orchestration and verification intelligence. They operate at different layers — Refact is a developer tool for the individual; Myelix Agents is an orchestration backend for a team.

Factory.ai — Enterprise Cloud PR Agent

Myelix wins on concurrency & code intelligence

Architecture: Enterprise cloud platform providing "Droids" — AI agents that review PRs, triage issues, and implement features asynchronously. Connects to GitHub, Jira, Linear, and Slack.

Factory.ai Droids are triggered by events (PR opened, issue labelled, etc.) and operate asynchronously in the cloud. They write code, run tests, and open PRs without a developer maintaining an active session.

Compared to Myelix Agents: Factory.ai's trigger-based async model is the closest commercial equivalent to Myelix Agents' Slack-triggered multi-agent flows. Key differences:

Factory.ai runs agents inside cloud containers (slow boot, heavy); Myelix Agents uses BEAM processes and Git Worktrees (instant, lightweight)
Factory.ai has no code-intelligence graph layer; Myelix Agents has Synapse
Factory.ai has no prefix caching economics; Myelix Agents' 3-Tier prompt architecture achieves ~90% cache hit rates

Devin — Cognition AI Cloud Visual Sandbox

Devin wins on visual observability

Architecture: Cloud-hosted visual sandbox. Devin runs in a fully managed cloud environment with a browser, terminal, and file system visible to the user in real time via a web UI. Users can watch Devin work and intervene via messages.

Unique Features: The visual "watchtower" interface. First commercially available fully autonomous software engineer. Supports shell, browser, code editor, and web search from within the sandbox.

Weaknesses: Extremely expensive per-session (cloud container per run). Slow to start. No code graph intelligence. Context is limited to files it reads during the session — no persistent AST index.

Compared to Myelix Agents: Devin is designed for delegated, single-thread cloud tasks with visual observability. Myelix Agents is designed for massively concurrent, verified, locally-run enterprise workloads. The BEAM VM can spawn 100 Myelix Agents sub-agents for the cost of 1 Devin session.

OpenHands (formerly OpenDevin) — OSS Container Agent

Myelix wins on efficiency & code intelligence

Architecture: Open-source Devin equivalent. Runs in a Docker container with a sandboxed shell, browser, and file system. Supports multiple LLM backends.

Compared to Myelix Agents: OpenHands is the open-source container-agent alternative. Its strength is reproducibility and open governance; its weakness is the same container overhead cost as Devin, with no code-graph intelligence layer.

3. Warp Factories vs. Myelix Agents: A Direct Comparison

These are the two systems in this ecosystem that have genuinely addressed multi-agent software factory workflows.

Dimension	Myelix Agents	Warp Factories
Compute Model	BEAM/OTP processes on host OS	Cloud containers (per-agent)
Isolation	Git Worktrees (lightweight, instant)	Docker containers (heavy, ~30s boot)
Agent definition	Elixir OTP Supervision Trees	YAML "Definitions as Code"
Code Intelligence	Synapse AST graph (50+ langs, local)	Embeddings-only RAG (cloud-synced)
Verification	5-Stage Satisfaction Evaluator Gates	Scorer + Self-improvement loop
Prefix Caching	✅ 3-tier (Stable/Context/Volatile)	❌
Trigger Sources	Slack, Cron, REST, CLI	Slack, GitHub, GitLab, Linear, Jira, Webhooks
Harnesses	Myelix Agents + Synapse MCP clients	Warp Agent, Claude Code, Codex, Gemini
RLHF / Self-improvement	✅ NxCritic LSTM reward model	✅ Scorers + benchmark comparison
Memory	✅ Session Learnings + Anti-pattern store	✅ Agent Memory (cross-harness, research preview)
Open Source	❌	❌ (client AGPL, platform closed)

4. Where Myelix Agents Is Uniquely Ahead

BEAM Concurrency

Spawning 20 parallel sub-agents on Myelix Agents costs the same RAM as spawning 1 Docker container in a competing platform. This is the fundamental architectural advantage. BEAM processes are microsecond-startup, kilobyte-footprint OS threads managed by a preemptive scheduler designed for millions of concurrent actors.

Synapse AST Graph

No other tool in this ecosystem maintains a persistent, queryable, 50-language code-knowledge graph locally, with exact caller/callee traversal, blast-radius analysis, and staged indexing. Cursor and Warp use embeddings-only RAG; Aider uses Tree-sitter repo maps. None have a live graph.

5-Stage Satisfaction Evaluator

Myelix Agents is the only system that structurally refuses to conclude a task until pre_edit, test_coverage, test_mapping, diff_review, and final_satisfaction gates all pass. This is not a policy — it is enforced by the SatisfactionEvaluator.Gates module in the OTP supervision tree.

3-Tier Prompt Architecture

The Stable/Context/Volatile split with prefix caching is unique. At scale, this dramatically reduces LLM API costs compared to competitors that rebuild full prompts every round. Measured cache hit rates exceed 90% on the Stable tier across multi-round sessions.

NxCritic RLHF Reward Model

Myelix Agents has an on-device LSTM reward model that scores trajectories and feeds into a self-improvement loop. No other local agent tool in this comparison ships with an RLHF loop. This compounds: each session improves future sessions.

CommandPolicy AST Filtering

Shell command safety is enforced via Elixir AST parsing of command strings — not regex allowlists/denylists. This is architecturally more robust than Warp's regex-based command denylist, which is susceptible to encoding tricks and shell metacharacter abuse.

5. The Ecosystem Map

Tool	Who Is It For?	Core Strength	Core Weakness
Cursor / Windsurf	Individual developers in an IDE	Real-time code editing UX, LSP	No concurrency, no autonomy
Warp	Teams wanting terminal + cloud agents	Best-in-class terminal UX + Warp Factories pipeline	Container overhead, no AST graph
Codex	CLI-first OpenAI users	Simple, sandboxed, Warp-integrated	No persistence, no orchestration
Claude Code	Anthropic users wanting a CLI agent	Excellent model, MCP extensible	No orchestration, no code graph
Aider	OSS enthusiasts wanting fast patching	Speed, composability, repo maps	Single-threaded, no verification
Hermes / OpenClaw	Community CLI users	MCP compatibility	Limited public capability info
Refact.ai	Privacy-first teams, on-premise	Fine-tuning, self-hosted	Shutting down cloud; single-agent
Factory.ai	Enterprise PR review / triage pipelines	Async event-driven cloud workflows	Container boot times, no code graph
Devin	Delegated single-task cloud work	Visual observability, full sandbox	Cost, speed, no code intelligence
OpenHands	OSS Devin alternative	Open governance, reproducibility	Container overhead, no code graph
Warp Factories	Engineering teams wanting software factories	Trigger integrations, definitions-as-code	No AST graph, container cost
Myelix Agents	Enterprise teams needing concurrent, verified autonomous development	BEAM concurrency, Synapse AST graph, 5-gate verification, RLHF self-improvement	Closed source, requires self-hosting