admin-valentin/agent-ecosystem
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
agent-ecosystem/docs/research/ai-orchestration-tools-part2.md
iliya 71db7f153b feat(research): add comprehensive documentation on AI agent protocols and orchestration tools 
- Introduced multiple new markdown files detailing the Agent Client Protocol (ACP), AI agent orchestration landscape, and various tools for managing multi-agent systems.
- Included in-depth analysis of protocol standards, governance structures, and emerging frameworks relevant to AI agent integration.
- Documented key features, architecture, and integration potential of various desktop and CLI orchestrators, enhancing understanding of the current ecosystem.
- Provided insights into best practices for integrating multi-provider agent support within the Electron framework.

This documentation aims to serve as a foundational resource for developers and stakeholders involved in AI agent orchestration and integration.
2026-03-25 14:47:52 +02:00

34 KiB
Raw Blame History

AI Agent Orchestrators & Dispatchers — Part 2

Research date: 2026-03-24 Focus: Provider-agnostic agent abstraction layers, dispatch systems, and multi-agent coding orchestrators Scope: NEW tools not covered in Part 1

Tier 1: Desktop Apps & ADEs (Agentic Development Environments)

These are the most relevant to our product — desktop applications that provide a UI layer for managing multiple coding agents.

1. Emdash (YC W26)

  • GitHub: https://github.com/generalaction/emdash
  • Stars: ~2,700+
  • License: Open source (exact license TBD)
  • Language: Electron-based desktop app
  • Unique: First YC-backed "Agentic Development Environment" (ADE). Run multiple coding agents in parallel, each isolated in its own git worktree, either locally or over SSH.

Agent providers: 22 CLI agents supported — Claude Code, Qwen Code, Amp, Codex, Gemini CLI, and more.

Architecture:

  • Each agent runs in its own git worktree with full isolation
  • Built-in ticket integrations: Linear, GitHub, Jira — pass tickets directly to agents
  • Remote development via SSH/SFTP with secure keychain credential storage
  • Built-in diff review, PR creation, CI/CD checks, and merge
  • Privacy-first: Emdash itself sends no code/chat data to any servers

Integration potential: DIRECT COMPETITOR. Very similar concept to our app. Key differences: Emdash is more a "parallel agent launcher" while we focus on team orchestration with inter-agent communication and kanban management.

Maturity: Active development, YC-backed, growing fast (966 -> 2700 stars in weeks). Available for macOS (Apple Silicon + Intel) and Linux.

Source: GitHub | emdash.sh | YC profile

2. Constellagent

  • GitHub: https://github.com/owengretzinger/constellagent
  • Stars: TBD (listed in awesome-agent-orchestrators)
  • License: Open source
  • Language: macOS desktop app
  • Unique: Each agent gets its own terminal, editor, and git worktree — all in one window. macOS-native UI.

Agent providers: Any CLI-based coding agent (Claude Code, Codex, Gemini CLI, etc.)

Architecture:

  • Side-by-side agent sessions with isolated git worktrees
  • Built-in terminal + code editor per agent
  • macOS-native (not Electron)

Integration potential: Simpler than our app but validates the "multi-agent desktop UI" market. macOS-only limits audience.

Source: GitHub

Tier 2: CLI Orchestrators with Provider Abstraction

3. ORCH

  • GitHub: https://www.orch.one/ (listed in awesome-agent-orchestrators)
  • Stars: TBD
  • License: MIT
  • Language: TypeScript
  • Unique: CLI runtime with formal STATE MACHINE for task lifecycle (todo -> in_progress -> review -> done). Agents talk to each other, share context, and run 24/7 as a daemon.

Agent providers: 5 built-in adapters — Claude (Anthropic), OpenCode (multi-provider via OpenRouter), Codex (OpenAI), Cursor, and a universal Shell adapter (anything that takes a prompt).

Architecture:

  • Each AI tool wrapped in adapter implementing common interface (src/infrastructure/adapters/)
  • Event bus with wildcard subscriptions for TUI activity feed
  • Git worktree isolation per agent
  • Inter-agent messaging + shared context
  • All state stored locally in .orchestry/ — no telemetry
  • "Set goal at 10pm, wake up to pull requests"

Integration potential: Very interesting adapter pattern. The common interface + event bus architecture is close to what we'd need for a provider abstraction layer. Could study their adapter implementations.

Source: orch.one | DEV article

4. Agent Swarm (Desplega AI)

  • GitHub: https://github.com/desplega-ai/agent-swarm
  • Stars: Notable stargazers (Andrew Ng, Chip Huyen). Exact count TBD.
  • License: MIT
  • Language: TypeScript
  • Unique: Full lead/worker coordination with Docker isolation, compounding memory, persistent agent identity (SOUL.md, IDENTITY.md), and DAG-based workflow engine.

Agent providers: Claude Code (primary), pi-mono. Provider adapter pattern via HARNESS_PROVIDER=claude|pi. Codex, Gemini CLI support planned.

Architecture:

  • Lead agent decomposes tasks, delegates to worker agents in Docker containers
  • MCP API server backed by SQLite for communication and state
  • Persistent searchable filesystem shared across swarm (agent-fs)
  • Compounding memory: agents learn from every session via summaries + OpenAI embeddings
  • Persistent identity: agents have evolving SOUL.md/IDENTITY.md files
  • DAG-based workflow engine with triggers, conditions, checkpoint durability
  • Integrations: Slack, GitHub, GitLab, Email, Linear
  • Dashboard UI with real-time monitoring + debug dashboard with SQL query interface

Integration potential: Most feature-rich orchestrator found. The persistent identity and compounding memory concepts are innovative. Dashboard UI could inspire features.

Source: GitHub | Docs | Dashboard

5. Kodo

  • GitHub: Listed in awesome-agent-orchestrators
  • Stars: ~37
  • License: Open source
  • Unique: SWE-bench verified. Autonomous multi-agent orchestrator with independent architect and tester verification stages in work cycles.

Agent providers: Claude Code, Codex, Gemini CLI

Architecture:

  • Directs agents through work cycles
  • Independent architect verification
  • Independent tester verification
  • SWE-bench validated results

Integration potential: Small project but interesting verification-centric workflow approach.

Source: awesome-agent-orchestrators

6. AgentFactory (Supaku)

  • GitHub: https://github.com/supaku/agentfactory
  • Stars: TBD
  • License: Open source
  • Language: TypeScript
  • Unique: "Software factory" with assembly-line pipeline (dev -> QA -> acceptance). Distributed worker pool via Redis. Exposes fleet as MCP server. Implements A2A protocol v0.3.0.

Agent providers: Claude, Codex, Spring AI (via AgentProvider interface)

Architecture:

  • AgentProvider interface for pluggable agent backends
  • Pipeline: development -> QA -> acceptance (like CI/CD for agents)
  • Distributed worker pool: webhook server + Redis queue + multiple worker nodes
  • MCP server exposure: any MCP-aware client can interact with fleet
  • A2A protocol support (v0.3.0) — operates as both client and server
  • Spring AI Bench integration for benchmarking
  • Scaffolding: @supaku/create-agentfactory-app
  • One-click deploy to Vercel/Railway
  • Linear integration for issue tracking

Integration potential: The A2A + MCP server approach is very forward-looking. Enterprise Java teams can use Spring AI agents alongside Claude/Codex.

Source: GitHub

Tier 3: Framework-Level Abstraction Layers

7. Mozilla any-agent

  • GitHub: https://github.com/mozilla-ai/any-agent
  • Stars: ~1,100+
  • License: Open source (Mozilla)
  • Language: Python
  • Unique: META-FRAMEWORK. Build agent once, switch frameworks by changing AgentFramework config parameter. Normalized logging via open-inference. Trace-first evaluation with LLM-as-judge.

Agent frameworks supported: Abstraction over multiple agent frameworks (not providers) — lets you swap between different frameworks without rewriting agent code.

Architecture:

  • Single interface to different agent frameworks
  • Normalized logging regardless of framework
  • Trace-first evaluation approach
  • Multi-agent via "Agents-As-Tools" pattern
  • Companion projects: any-llm (LLM provider abstraction), any-guardrail, Agent Factory (natural language to agents), mcpd ("requirements.txt for agentic systems")

Integration potential: Different abstraction level than what we need. Useful if we want to abstract over agent frameworks rather than coding agent CLIs. The mcpd tool for MCP server management is interesting.

Source: GitHub | Blog | Docs

8. VoltAgent

  • GitHub: https://github.com/VoltAgent/voltagent
  • Stars: TBD (active GitHub org with multiple repos)
  • License: MIT
  • Language: TypeScript
  • Unique: "Refine.dev for AI agents" — TypeScript-first with n8n-style visual debugging console. Multi-agent orchestration with resumable streaming and voice support.

Agent providers: OpenAI, Anthropic, Google, and others — swap by changing config, not code.

Architecture:

  • LLM-agnostic: provider swap via config
  • Memory adapters (durable, cross-run)
  • Resumable streaming: clients reconnect to in-flight streams after refresh
  • RAG + Knowledge Base: managed document ingestion, chunking, embeddings, search
  • Guardrails: runtime input/output validation
  • Evals: built-in eval suites
  • Voice: TTS/STT with OpenAI, ElevenLabs, custom providers
  • VoltOps Console: observability, automation, deployment, evals (cloud & self-hosted)
  • MCP docs server for AI coding assistants

Integration potential: Great TypeScript framework if we want to build our own agent abstraction. The resumable streaming pattern is relevant for Electron apps.

Source: GitHub | voltagent.dev

9. Mastra

  • GitHub: https://github.com/mastra-ai/mastra
  • Stars: 7,500+ (as of early reports, likely higher now)
  • License: Open source (EE features source-available under enterprise license)
  • Language: TypeScript
  • Created by: Team behind Gatsby (YC-backed)
  • Unique: "Batteries-included TypeScript AI framework." Used by Replit Agent 3 (improved task success 80% -> 96%). Supports 81 LLM providers and 2,436+ models via Vercel AI SDK.

Agent providers: 40+ providers via Vercel AI SDK (OpenAI, Anthropic, Gemini, etc.)

Architecture:

  • Model routing: 40+ providers through one interface
  • Human-in-the-loop: suspend/resume with stored execution state
  • Context management: conversation history, data retrieval, working + semantic memory
  • MCP servers: expose agents/tools/resources via MCP
  • Integration with React, Next.js, Node.js
  • Serverless deployment: Vercel, Cloudflare, Netlify, or Mastra hosting
  • npm create mastra@latest for quick start

Integration potential: Very mature TypeScript SDK. Could be used as an underlying agent framework in our Electron app. The human-in-the-loop suspend/resume is exactly what we need for kanban workflows.

Source: GitHub | mastra.ai | YC profile

Tier 4: Coding Agent Platforms (Individual Agents with Multi-Provider Support)

10. Goose (Block)

  • GitHub: https://github.com/block/goose
  • Stars: 27,000+
  • License: Apache 2.0
  • Language: Rust
  • Unique: By Block (Square, Cash App). 25+ LLM providers, 3,000+ MCP servers. Contributed to Linux Foundation's Agentic AI Foundation alongside Anthropic's MCP and OpenAI's AGENTS.md.

Agent providers: 25+ LLM providers (OpenAI, Anthropic, Google, DeepSeek, local via Ollama). Can even use Claude Code as a model provider inside Goose.

Architecture:

  • Multi-provider with multi-model configuration (use different models for different tasks in same session)
  • Subagents for parallel task execution with isolated workspaces
  • MCP-native (among first agents to support MCP)
  • CLI + Desktop app (not IDE-locked)
  • Recipes system for reusable workflows
  • Completely free + open source; you only pay LLM API costs

Integration potential: Goose itself is a coding agent, not an orchestrator. But its multi-provider architecture and MCP integration patterns are worth studying. Could be one of the agents our UI orchestrates.

Source: GitHub | block.github.io/goose | AI Tool Analysis Review

11. OpenCode

  • GitHub: https://github.com/opencode-ai/opencode
  • Stars: 95K-120K+ (massive growth, surpassed Claude Code in stars)
  • License: Open source
  • Language: Go (Bubble Tea TUI)
  • Created by: Team behind SST (Serverless Stack) and terminal.shop
  • Unique: Go-based terminal agent with 75+ LLM providers. Built-in TUI with Vim-like editor. 5M+ monthly developers.

Agent providers: 75+ providers — OpenAI, Anthropic, Google Gemini, AWS Bedrock, Groq, Azure OpenAI, OpenRouter, and more.

Architecture:

  • Interactive TUI built with Bubble Tea
  • Session management with persistent SQLite storage
  • Multiple agent types: plan agent (analysis), general-purpose agent (full tool access)
  • Parallel work units
  • MCP integration for external tools
  • LSP integration for code intelligence
  • Provider-agnostic philosophy: "as models evolve, being provider-agnostic is important"

Integration potential: OpenCode is a single-agent tool, not an orchestrator. However, it's the most popular open-source alternative to Claude Code. Worth considering as a supported runtime for our orchestrator.

Source: GitHub | opencode.ai | OpenCode Docs - Agents | OpenCode Docs - Providers

12. OpenHands (formerly OpenDevin)

  • GitHub: https://github.com/OpenHands/OpenHands
  • Stars: 68,600+
  • License: MIT
  • Language: Python
  • Unique: Cloud coding agent platform with $18.8M Series A. Solves 87% of bug tickets same day. Event stream architecture with typed events.

Agent providers: 100+ providers via LiteLLM (OpenAI, Anthropic, Google, etc.). Git providers: GitHub, GitLab, Bitbucket, Azure DevOps, Forgejo.

Architecture:

  • Event stream architecture: all agent-environment interactions as typed events through central hub
  • Agent -> Runtime -> EventStream -> LLM pipeline
  • Hierarchical agent coordination via delegation tool
  • Sub-agents as independent conversations inheriting parent config
  • Distributed deployment: WebSocket for agent/runtime communication
  • Isolated Docker/Kubernetes environments
  • V1 SDK transition: moving from mandatory Docker to optional sandboxing
  • Software Agent SDK for building custom agents

Integration potential: Enterprise-grade platform. The event stream architecture and typed events pattern could inspire our agent communication protocol.

Source: GitHub | openhands.dev | Software Agent SDK paper

Tier 5: Specialized Multi-Agent Coding Systems

13. Liza (Disciplined Multi Coding Agent System)

  • GitHub: https://github.com/liza-mas/liza
  • Stars: TBD
  • License: Open source
  • Unique: "Lisa Simpson vs Ralph Wiggum" philosophy. 55+ LLM failure modes mapped to countermeasures. Behavioral contracts, blackboard coordination, and explicit state machine. MOST disciplined approach to multi-agent coding.

Architecture:

  • Behavioral contract with Tier 0 invariants (never violated)
  • Blackboard coordination: shared file tracks goals, tasks, assignments, history
  • Stateless agents with external specs for context handoff
  • Approval Request mechanism forces reasoning before acting
  • Deterministic pre/post hooks at role transitions
  • Orchestrator-routed model selection
  • Agent roles: Coder, Security Auditor, Security Audit Reviewer
  • Sprint-based workflow: autonomous within sprints, human reviews between sprints
  • CLI: liza setup, liza init, liza agent coder, liza validate, liza watch, liza sprint-checkpoint

Integration potential: The behavioral contract and blackboard coordination concepts are academically interesting and could improve agent reliability.

Source: GitHub

14. Multi-Agent Coding System (Danau5tin)

Architecture:

  • Orchestrator + Explorer + Coder agents with knowledge artifacts
  • Context Store: persistent knowledge layer with selective injection
  • Trust Calibration Strategy: adaptive delegation based on task complexity
  • Orchestrator cannot read/modify code directly — operates at architectural level only
  • Companion project: Orca-Agent-RL (14B model, trained on 32x H100s)

Integration potential: The Context Store pattern for multi-agent knowledge sharing is a novel approach worth studying.

Source: GitHub | Hacker News

15. Open SWE (LangChain)

  • GitHub: https://github.com/langchain-ai/open-swe
  • Stars: 7,700+
  • License: MIT
  • Language: Python
  • Unique: Built on LangGraph Deep Agents framework. Multi-agent architecture (Manager, Planner, Programmer, Reviewer). Captures patterns used by Stripe, Ramp, Coinbase for internal coding agents.

Agent providers: Any LLM via LangGraph. Multiple sandbox providers: Modal, Daytona, Runloop, LangSmith.

Architecture:

  • Manager -> Planner -> Programmer -> Reviewer pipeline
  • Isolated Daytona sandboxes per task
  • Subagent orchestration via Deep Agents task tool
  • Middleware hooks: deterministic middleware around agent loop
  • AGENTS.md support: read from sandbox, injected into system prompt
  • Async & cloud-native: multiple tasks in parallel, "double texting" support
  • Integrations: Linear, Slack, GitHub

Integration potential: Enterprise-grade coding agent framework. The middleware hook pattern and AGENTS.md support are interesting patterns.

Source: GitHub | LangChain Blog

16. DeerFlow 2.0 (ByteDance)

  • GitHub: https://github.com/bytedance/deer-flow
  • Stars: 37,000+
  • License: MIT
  • Language: Python
  • Unique: ByteDance's "SuperAgent harness." Ground-up rewrite of v1. Multi-service architecture with Nginx reverse proxy. Skills system for extensibility. #1 GitHub Trending within 24h of launch.

Agent providers: Model-agnostic — any OpenAI-compatible API (GPT-4, Claude, Gemini, DeepSeek, local models via Ollama).

Architecture:

  • Harness (core): agent orchestration, tools, sandbox, models, MCP, skills, config
  • App layer: FastAPI Gateway API + IM channel integrations (Feishu, Slack, Telegram)
  • Lead agent decomposes tasks, spawns sub-agents with scoped contexts
  • Docker-sandboxed execution per sub-agent (own filesystem, bash terminal)
  • Skills system: Markdown-based workflow definitions with best practices
  • Persistent JSON memory system (user context, history, facts with confidence scores)
  • Three sandbox modes (configurable via config.yaml)
  • MCP servers with OAuth token flows

Integration potential: Impressive scale and ByteDance backing. Skills system is interesting — Markdown-based workflow definitions could be adapted for our agent team recipes.

Source: GitHub | deerflow.tech | DeepWiki analysis

Tier 6: Infrastructure & Runtime Frameworks

17. Dapr Agents (CNCF)

  • GitHub: https://github.com/dapr/dapr-agents
  • Stars: Part of Dapr ecosystem (34K+ stars for main Dapr project)
  • License: Open source (CNCF)
  • Language: Python (only)
  • Unique: v1.0 GA announced at KubeCon Europe 2026. DurableAgent class: every LLM call and tool execution is a checkpoint. Kill process mid-workflow, resume from last saved point.

Agent providers: LLM provider decoupling via Dapr Conversation API — swap LLMs without code changes (OpenAI, Anthropic, AWS Bedrock, etc.)

Architecture:

  • Kubernetes-native: distribute thousands of agents across pods/nodes
  • DurableAgent with checkpoint/resume
  • Multi-agent via Dapr pub/sub messaging
  • Coordination models: LLM-based, random, round-robin
  • SPIFFE identity for agent-to-agent authorization
  • Distributed tracing via OTEL + Prometheus metrics
  • mTLS encrypted communication
  • Enterprise adoption: ZEISS, EU logistics companies

Integration potential: Overkill for desktop app, but the DurableAgent checkpoint/resume pattern could inspire our agent crash recovery. Python-only is a limitation.

Source: GitHub | Diagrid Blog | KubeCon announcement

18. Sandcastle

  • GitHub: https://github.com/gizmax/Sandcastle
  • Stars: TBD
  • License: Open source
  • Language: Python
  • Unique: EU AI Act compliance built-in. 63 integrations. YAML-defined workflows. Smart model routing (quality/cost/latency constraints per step). 118 built-in + 118 community workflow templates.

Agent providers: OpenAI, Anthropic, plus many more via multi-provider routing. Budget pressure detection forces cheaper models.

Architecture:

  • YAML workflow definitions with DAG dependencies and parallel branches
  • 4 sandbox backends: E2B cloud microVMs, Docker, Cloudflare Workers edge, local subprocess
  • Smart model routing with historical performance data
  • 5 browser automation modes (Playwright, Computer Use, DOM Extract, LightPanda, Browserbase)
  • Real-time SSE dashboard (runs, costs, schedules, approvals, experiments)
  • A/B testing models and prompts per step with auto-deployment
  • Replay & checkpoints: re-run from any step
  • PII redaction and tamper-evident audit trail
  • Agent runtime with circuit breaker and pool management

Integration potential: Enterprise-grade workflow orchestrator. The smart model routing and A/B testing capabilities could be interesting for our team management feature.

Source: GitHub | gizmax.cz/sandcastle

19. AgentScope + Runtime (Alibaba/Tongyi Lab)

Agent providers: OpenAI, DashScope, Gemini, Anthropic, self-hosted open-source models. Provider-agnostic via formatter system.

Architecture:

  • AgentScope: agent development framework with multi-agent collaboration
  • AgentScope Runtime: separate deployment infrastructure (sandboxing, state management, memory)
  • Runtime is framework-agnostic — works with other agent frameworks too
  • Agent-as-API: white-box development experience
  • Multi-layer hook system for observability (OpenTelemetry integration)
  • Serverless deployment support (Alibaba Cloud FC)
  • Java implementation (Spring AI Alibaba, Langchain4j)
  • ReAct agent built implementation-agnostic

Integration potential: The separation of agent framework from runtime is architecturally clean. The framework-agnostic runtime concept aligns with our need for a provider-neutral orchestration layer.

Source: GitHub (main) | GitHub (runtime)

20. OpenAgentsControl (OAC)

  • GitHub: https://github.com/darrenhinde/OpenAgentsControl
  • Stars: ~2,900
  • License: Open source
  • Language: Built on OpenCode
  • Unique: Plan-first, approval-based execution. "Minimal Viable Information" (MVI) principle = 80% token reduction. Editable agents via Markdown files.

Agent providers: Model-agnostic — Claude, GPT, Gemini, local models (Ollama, LM Studio). Built on OpenCode.

Architecture:

  • Propose -> Approve -> Execute model
  • MVI principle: load only relevant patterns per task (80% token savings)
  • Editable agents: modify behavior by editing Markdown files
  • Custom Agent System Builder wizard
  • Coding patterns committed to repos (team consistency)
  • Multi-language: TypeScript, Python, Go, Rust

Integration potential: The MVI token reduction technique and editable Markdown agents are useful ideas. Plan-first approach aligns with structured team workflows.

Source: GitHub | BrightCoding review

21. NeuroLink (Juspay)

  • GitHub: https://github.com/juspay/neurolink
  • Stars: ~119
  • License: MIT
  • Language: TypeScript
  • Unique: Enterprise-grade unified API for 12 major AI providers and 100+ models. Extracted from production systems at Juspay. Multi-provider failover and automatic cost optimization.

Agent providers: 12 providers unified: OpenAI, Google, Anthropic, AWS, Azure, Groq, Together AI, Mistral, Cohere, Fireworks, Cloudflare, Ollama. 300+ models via OpenRouter integration.

Architecture:

  • Single API for 12+ providers (switch with one parameter change)
  • 64+ built-in tools and MCP servers
  • Multi-step agentic loops with per-step tool execution control
  • Persistent memory (Redis/S3/SQLite)
  • HITL workflows
  • Structured output with Zod schemas
  • Auto cost optimization and multi-provider failover
  • LiteLLM integration for 100+ models
  • TypeScript SDK + professional CLI

Integration potential: Good TypeScript SDK for unified LLM access. If we need to add direct LLM provider abstraction (beyond just spawning CLI agents), NeuroLink's approach is solid.

Source: GitHub

22. Pi-mono (badlogic)

  • GitHub: https://github.com/badlogic/pi-mono
  • Stars: TBD
  • License: Open source
  • Language: TypeScript (npm packages)
  • Unique: Minimal terminal coding harness with 4 modes: interactive, print/JSON, RPC, and SDK for embedding. Extensible via TypeScript Extensions, Skills, Prompt Templates, and Themes.

Agent providers: Multi-provider via Api type union. Providers added by extending the API identifier system.

Architecture:

  • Monorepo with multiple packages (packages/coding-agent, etc.)
  • 4 modes: interactive, print/JSON, RPC (process integration), SDK (embedding)
  • OpenClaw SDK integration for real-world use
  • Extension system: TypeScript Extensions, Skills, Prompt Templates, Themes
  • Packaged as npm packages for sharing
  • Used as a provider in Agent Swarm (HARNESS_PROVIDER=pi)

Integration potential: The RPC and SDK modes are interesting for embedding a coding agent into our Electron app. Minimal footprint philosophy is appealing.

Source: GitHub

23. Agentic Fleet (Qredence)

  • GitHub: https://github.com/Qredence/agentic-fleet
  • Stars: TBD
  • License: Open source
  • Language: Python (backend) + React 19 + TypeScript (frontend)
  • Unique: Built on Microsoft Agent Framework's Magentic Fleet pattern. Five-phase pipeline: analysis -> routing -> execution -> progress -> quality.

Architecture:

  • Backend: Python 3.12/3.13, FastAPI, Typer CLI, DSPy, Microsoft Agent Framework
  • Frontend: React 19, TypeScript, Vite, Tailwind CSS, Radix UI, Shadcn UI
  • ToolRegistry adapters (Tavily search, browser automation, code execution, MCP)
  • Real-time SSE/WebSocket streaming
  • Five-phase task pipeline

Integration potential: Good example of combining Microsoft Agent Framework with a React frontend. The ToolRegistry adapter pattern is relevant.

Source: GitHub

24. Plandex

  • GitHub: https://github.com/plandex-ai/plandex
  • Stars: 15,086
  • License: MIT
  • Language: Go
  • Unique: Terminal-based AI coding with 2M token context, full version control for AI plans (branches, diff review), and cumulative diff review sandbox.

Agent providers: Combine models from Anthropic, OpenAI, Google, and open source providers.

Architecture:

  • 2M token context handling (~100k per file)
  • Tree-sitter project maps for 20M+ token directories
  • Version control for plans (branches, compare models)
  • Cumulative diff review sandbox (changes separate until approved)
  • Full autonomy capable but highly configurable step-by-step review
  • Git integration with auto-commit

Integration potential: Single agent, not an orchestrator. But the plan version control and diff sandbox concepts are relevant to our code review feature.

Source: GitHub | plandex.ai

Tier 7: Evolving / Archived (Notable Mentions)

25. ControlFlow -> Marvin 3.0 (PrefectHQ)

Source: GitHub (ControlFlow) | GitHub (Marvin)

Summary Comparison Table

Tool Type Stars Language Agent Providers Desktop App Key Differentiator
Emdash ADE 2,700+ Electron 22 CLI agents Yes YC W26, tickets integration
Constellagent ADE TBD macOS native Any CLI agent Yes (macOS only) Terminal+editor+worktree per agent
ORCH CLI TBD TypeScript 5 adapters TUI State machine, inter-agent messaging
Agent Swarm CLI+Dashboard TBD TypeScript Claude, Pi Dashboard UI Compounding memory, persistent identity
AgentFactory CLI+Web TBD TypeScript Claude, Codex, Spring AI Dashboard A2A protocol, MCP server, Redis pool
Goose Agent 27K+ Rust 25+ LLM providers Desktop+CLI Linux Foundation, MCP-native
OpenCode Agent 95K+ Go 75+ providers TUI Fastest-growing, Bubble Tea UI
OpenHands Platform 68K+ Python 100+ via LiteLLM Web UI $18.8M Series A, event stream arch
DeerFlow Harness 37K+ Python Any OpenAI-compatible Web UI ByteDance, skills system
Open SWE Framework 7,700+ Python Any via LangGraph No LangChain, enterprise patterns
Mastra Framework 7,500+ TypeScript 40+ providers No By Gatsby team, used by Replit
Mozilla any-agent Meta-framework 1,100+ Python Framework abstraction No Switch frameworks, not providers
VoltAgent Framework TBD TypeScript OpenAI, Anthropic, Google Console UI Resumable streaming, voice
Dapr Agents Runtime Part of 34K+ Python Via Conversation API No CNCF, Kubernetes-native, durable agents
Liza System TBD CLI Any LLM No Behavioral contracts, 55+ failure modes
Sandcastle Orchestrator TBD Python Multi-provider routing Dashboard EU AI Act, YAML workflows, 118 templates

Key Architectural Patterns Observed

1. Agent Runtime Interface Pattern

Used by: ORCH, Overstory, Agent Swarm, AgentFactory

  • Define a common interface (spawn, configure, detect readiness, parse transcript)
  • Each agent provider gets an adapter implementing this interface
  • Swap providers without changing orchestration logic

2. Git Worktree Isolation Pattern

Used by: Emdash, Constellagent, ORCH, Agent Swarm, ComposioHQ

  • Standard approach for multi-agent parallel work
  • Each agent gets its own worktree + branch
  • Merge back via PR/conflict resolution

3. Event Stream / Pub-Sub Architecture

Used by: OpenHands, ORCH, Dapr Agents

  • All agent interactions as typed events through central hub
  • Enables observability, replay, and debugging

4. Checkpoint/Resume (Durable Execution)

Used by: Dapr Agents, Sandcastle, Mastra

  • Every step saves a checkpoint
  • Kill process mid-workflow -> resume from last saved point
  • Critical for production reliability

5. Lead-Worker Decomposition

Used by: Agent Swarm, DeerFlow, Open SWE, Claude Agent Teams (ours)

  • Lead agent decomposes tasks
  • Workers execute in isolation
  • Results stitched back together

Integration Relevance for Claude Agent Teams UI

Direct Competitors (UI level)

  1. Emdash — Most direct competitor. YC-backed. 22 agents. But lacks kanban, inter-agent communication, and team orchestration.
  2. Constellagent — macOS-only. Simpler scope.

Architectural Inspiration

  1. ORCH — Adapter interface pattern for agent providers + state machine for task lifecycle
  2. Agent Swarm — Compounding memory + persistent identity + dashboard UI
  3. AgentFactory — A2A protocol + MCP server exposure + pipeline stages
  4. VoltAgent — TypeScript-first framework with resumable streaming (relevant for Electron)
  5. Mastra — Human-in-the-loop suspend/resume via stored state

Worth Studying

  1. Liza — Behavioral contracts for agent reliability
  2. Mozilla any-agent — Meta-framework approach
  3. OpenHands — Event stream architecture at scale
  4. DeerFlow — Skills system (Markdown-based workflow definitions)

Key Competitive Advantages We Have

  • Kanban board — NO ONE else has this for agent orchestration
  • Inter-agent communication — Most tools only have lead-worker, not peer-to-peer
  • Code review workflow — Diff view per task with approve/reject
  • Claude Code Agent Teams native support — Built specifically for Claude's team protocol
  • Context monitoring — Token usage tracking by category (unique)
  • Zero-setup onboarding — Built-in Claude Code installation