andyrewlee/awesome-agent-orchestrators

A curated list of open source and source available tools for orchestrating agents.

Prefer a web version? Visit agent-orchestrators.com for more information on each tool.

Run several agents at once and review each diff. Parallel Coding Agents — Terminal (TUI/CLI) if you live in tmux; Desktop & Web if you want a GUI or phone access.

Keep an agent working while you're away. Autonomous Loop Runners drive one goal until it verifies; Autonomous Task Runners pull work from an issue tracker, board, or schedule.

Have agents split a large job between themselves. Multi-Agent Swarms.

Message an agent instead of opening a tool. Personal Assistants stay running, remember across sessions, and pick up work from a chat thread — general tasks, not only code.

Build your own orchestrator. Agent Infrastructure & Primitives — control planes, coordination protocols, harness adapters, and runtimes.

• Parallel Coding Agents — Terminal (TUI/CLI)
• Parallel Coding Agents — Desktop & Web
• Multi-Agent Swarms
• Autonomous Loop Runners
• Autonomous Task Runners
• Agent Infrastructure & Primitives
• Personal Assistants
• Resting

Run and supervise several agent sessions side by side from a terminal — tmux panes, git worktrees, and TUI dashboards.

• agent-console - Rust TUI that finds Codex and Claude Code sessions from the providers' own transcripts, including ones started elsewhere, and resumes their native UI rather than replacing it. No tmux or worktrees.
• agent-deck - One TUI covering sessions across Claude Code, Codex, Gemini, and OpenCode, with live status and resume for each.
• agent-manager - Live-status tmux TUI with a prompt that lands in the pane without attaching, and in-terminal diff review that sends line comments back to the agent. Claude Code, Codex, OpenCode, Grok, Gemini CLI, Pi, Hermes.
• agent-session-manager - Live tmux TUI with session groups, resume and fork, diff review, and mobile push when an agent needs an answer. Claude Code, Codex, Gemini, Aider, Amazon Q, OpenCode.
• agent-of-empires - Pairs a TUI with a matching web view, so the same sessions stay reachable from a phone. Claude Code, Codex, OpenCode, Gemini, Mistral Vibe.
• agentbox - Gives each agent its own sandboxed VM — local Docker or cloud via Hetzner, Daytona, Vercel, or E2B — with sub-second checkpoint starts.
• agterm - Native macOS terminal with named workspaces, a live dashboard, attention states, and a scriptable control API.
• ai-devkit - CLI control plane that runs agent sessions in managed tmux, sends prompts and logs to running agents from the terminal or a TUI console, and gives every agent one setup with shared local memory, verification skills, and lifecycle workflows. Claude Code, Codex, Pi, and more.
• amux - Minimal TUI for spawning parallel coding agents in git worktrees.
• Calyx - Native macOS terminal built on libghostty with an approval inbox for permission prompts, a working/blocked/idle sidebar, and in-terminal diff review.
• claude-squad - Runs each agent as a detached background session with its own worktree, so work continues after you close the pane. Claude Code, Codex, OpenCode, Amp.
• cmux - Ghostty-based macOS terminal with vertical tabs and per-agent notifications, built for keeping many concurrent sessions legible.
• Cyclops - Coordinates coding agents running in tmux through a durable mailbox with guarded terminal notifications, FIFO delivery per recipient, and fail-closed human-composer protection, with an optional workspace UI for overseeing the team. Codex CLI, Claude Code, Antigravity, Cursor Agent.
• dmux - Dev agent multiplexer pairing coding agents with git worktrees over tmux.
• herdr - Background runtime that owns your agents' terminals: sessions survive reboot and reattach from any terminal or SSH, panes are marked working/blocked/idle, and agents themselves spawn panes and prompt each other over a CLI and socket API. One Rust binary.
• openkanban - Kanban board for orchestrating coding agents, rendered entirely in the terminal.
• pappardelle - TUI that turns a description into a Linear, Jira, or beads issue, a git worktree, a PR, and a Claude Code session beside a companion pane, wired together in a 3-pane tmux layout.
• Prowl - Native macOS command center for running coding agents in parallel, with vertical tabs, a live canvas view of every running session, and a command palette. Claude Code, Codex, and more.
• ReevesAgents - TUI, Web UI, and CLI that run coding CLIs side by side in tmux windows, plus an opt-in MCP server so one agent can spawn, read, steer, and stop the others. Claude Code, Codex, OpenCode, Hermes, Kimi, DeepSeek, Qwen, Pi, Aider, and more.
• repomon - Rust TUI that supervises a fleet across many repositories at once, in durable tmux sessions you can approve from your phone.
• Rove - TUI orchestrator that gives each task its own git worktree and branch, with sessions that survive detach or dropped SSH, a Kanban board whose cards launch sessions and get moved by agents, and a rove api for agents to dispatch tasks that report back. Claude Code, Codex, Copilot, Kimi, Pi, Gemini CLI, OpenCode, Cursor Agent, and any CLI you register.
• termany - Terminal that keeps many agent sessions in one window, tagging each pane working/done/needs-attention from the running job rather than the shell prompt, with diffs, worktrees, port handling, remote hosts, and token cost in the same place. Claude, Codex, Gemini, Grok Build, OpenClaw, Hermes, OpenCode, Cursor, Kimi, OMP.
• thurbox - TUI orchestrator with remote SSH sessions, inter-session messaging, and a native code-review view. Works with any CLI agent you define.
• tmux-ide - Turns any project into a tmux IDE from a checked-in ide.yml, including preset agent-team layouts.
• tuios - A terminal window manager that knows what your agents are doing. Tile panes across nine workspaces in the terminal you already use. A daemon keeps sessions running when you detach and reaches your other machines. The coding agents in your panes report what they are doing, and one Inbox holds everything they are waiting on. Agent integration for claude-code, codex, gemini-cli, opencode, amp, antigravity, copilot, crush, cursor-agent, devin, droid, grok, hermes, kilo, kimi, pi, omp, qoder, qwen.
• Vigil - Native macOS terminal where a manager agent runs the tree — spawning workers and sub-managers, detail flowing down, summaries rolling up — while every node stays the CLI's own TUI you can take over. Claude Code, Codex, OpenCode.
• YYLO - Command-line orchestrator for coding agents with typed task, validation, merge, and release-readiness boundaries: each task runs in a dedicated branch and worktree, and a risk-based merge queue reviews the result with receipt-backed changes. Pi and Codex subagents.

The same parallel-sessions workflow as a desktop app or browser/mobile dashboard, with diff review and merge.

• agent-orchestrator - Agent IDE for fleets that plans the work, spawns the agents, then fixes CI failures and merge conflicts without being asked.
• agent-session-manager-desktop - Desktop GUI over tmux where each session holds agent and shell tabs with per-tab working directories; waiting agents raise a header counter you can answer without switching tabs, and ntfy push carries it to your phone. Linux, macOS, Windows. Claude Code, Codex, Gemini, Aider.
• agent-squid - Browser UI organized into named lanes (#topic@agent), with context shared across agents and a realtime quota gauge.
• AGX - Wake-work-sleep checkpointing keeps a persistent agent team on long objectives, with human gates between cycles.
• ai-maestro - Dashboard spanning multiple machines, adding memory search, code-graph queries, and agent-to-agent messaging. Claude, Aider, Cursor.
• AI4Kanban - AI project manager that turns rough ideas into actionable tasks, coordinates coding agents through planning and implementation, and builds shared project memory from decisions. Humans steer priorities and make key decisions through a desktop and web interface.
• aizen - macOS workspace that organizes worktrees, environments, and agent sessions per project.
• alas - Native macOS workspace for the whole agent loop: libghostty terminals or native chat panes across every worktree, on your Mac or over SSH, with comment-based review, in-app merge, and pickup from your phone.
• Alethe - Local-first desktop workspace where agents and shells run as real PTYs in split panes and custom grids across projects, surviving pane close and app restart. Suspend idle groups to reclaim memory and resume with scrollback intact. Claude Code, Codex, OpenCode.
• Aperant - Runs up to 12 agent terminals with a self-validating QA loop and automatic conflict resolution when merging back to main.
• ateam - macOS and iPhone app orchestrating Claude Code, OpenCode, and Codex crews, each isolated in its own git worktree.
• automaker - Describe features on a Kanban board and agents implement them in isolated worktrees, running tests and committing as they go.
• bb - Self-controlling agentic IDE that orchestrates multiple coding agents in live threads you can follow, steer, or hand off, driven from a desktop app, web app, CLI, or HTTP API.
• Berd - Block's open-source desktop app for working with AI agents: project chats with per-folder worktree behavior over the Goose backend, with agents, skills, connections, and agent sharing in one place.
• Claude Command Center (CCC) - Local dashboard for spawning, monitoring, and resuming sessions across Claude Code, Codex, Cursor, Antigravity, and Kilo Code.
• clave - Native macOS app with split and grid layouts, session groups, SSH remote sessions, and usage analytics for Claude Code.
• clideck - Chat-app-style dashboard with autopilot routing between agents and full control from a phone. Claude Code, Codex, Gemini CLI, OpenCode.
• CodeNomad - Desktop and web workspace around the OpenCode CLI whose SideCars embed local tools like VS Code and terminals as tabs.
• collaborator - Arranges terminals, editors, and files as tiles on an infinite pan-and-zoom canvas instead of tabs.
• constellagent - macOS app giving each agent its own terminal, editor, and git worktree in a single window.
• diri - Native macOS app running Claude Code, Codex, Cursor, Gemini, and shells in parallel across git worktrees or remote hosts, with live status, session persistence across restarts, a menu-bar rollup, and an MCP server for agents to spawn others.
• DockTerm - Cross-platform terminal workspace that runs the real Claude Code in one pane per project, with a live sub-agent view, diff review, Git, and permission prompts that pop out of the Mac notch.
• dorothy - Desktop app combining agent orchestration with automations, Kanban management, and MCP servers.
• Dray - Native desktop app wrapping Claude Code, Codex, fx, and pi in a chat UI, with one worktree per session plus diff, PR, and issue panels and an embedded browser.
• Emdash - Agentic development environment running parallel agents against any model provider.
• EvoFlux - Local-first desktop workspace coordinating specialist AI agents across conversations, files, terminal, browser, Git, memory, and verification.
• Fletch - Native macOS IDE that seals each agent in its own repo clone under Seatbelt or Docker, serves each a shared symbol and call-graph index over MCP, and gates every step on tests or your approval. Claude Code, Codex, Cursor, OpenCode.
• Garcon - Self-hosted browser and mobile workspace with diff review, Git/PR workflows, mobile approvals, scheduling, and cross-agent transfers. Seven CLI agents.
• Ghostex - Native macOS workspace (Rust/GPUI) running CLI agents side by side in low-RAM Ghostty terminals, with embedded browser and editor panes, a Kanban board, and iOS/Android session access. Claude Code, Codex, OpenCode.
• GraphCode - macOS app that wires agent sessions into a graph: each node is a live terminal you can attach to mid-run, each edge a hand-off, message, or spawn that fires while you're away. Claude Code, Codex, Copilot CLI, OpenCode, pi.
• Happy - Desktop app and CLI running agent sessions side by side on your own machine or server, with an end-to-end encrypted iOS/Android app for the same sessions. Claude Code, Codex, and Grok in the desktop app; Claude Code, Codex, and any ACP agent from the CLI.
• Helicon - Unofficial desktop and web app, not affiliated with Meta, that puts threads from every project in one sidebar with inline diffs, approvals, cost tracking, and a VS Code and Cursor extension. Muse Code.
• humanlayer - Human-in-the-loop control for coding agents on hard problems; the repo notes its code is now largely deprecated in favor of a rebuild.
• IM.codes - Mobile and web control layer built for away-from-desk continuation, with terminal access, git views, localhost preview, and scheduled tasks. Claude Code, Codex, Gemini CLI.
• Intent - Desktop app for coordinating coding agents at scale: workspaces, notes, tasks, git, and terminals in one place, backed by a Rust daemon, with an iOS companion.
• intentic - Browser and mobile workspace where every agent gets a persistent Docker sandbox on a machine you own plus a git worktree of its own, reached over an outbound-only Cloudflare tunnel, so runs keep going after you close the tab. Plan mode, per-hunk diff review, an environment Dockerfile the agent proposes and you approve, credential capabilities injected per turn, and schedule, webhook or event triggers. Claude Code, Codex, Grok, Kimi Code, Gemini. MIT.
• ivy-tendril - Drives agents through a plan-based lifecycle with verification gates, self-improving memory, and human checkpoints. Claude Code, Codex, Antigravity, Copilot, OpenCode.
• jean - Desktop and web app for orchestrating agents across multiple projects and their git worktrees. Claude, Codex, OpenCode.
• kandev - Kanban workbench whose multi-step workflows assign a different agent per step behind human gates, running locally, in Docker, over SSH, or in cloud executors.
• MonoCode - Tauri desktop UI where tabs are agent sessions, running Claude Code, Codex, Cursor, Grok Build, OpenCode, Pi, omp, and fx on your existing subscriptions. macOS, Linux, and Windows.
• MulmoTerminal - Browser grid of live Claude Code / Codex sessions started with one npx command. Each cell is a real PTY with a colour-coded status, tmux-backed persistence, and a git worktree per cell. For Claude Code, needs-you is shown separately from done, read from the CLI's own hooks.
• MultiCC - Self-hosted workspace where one chat task and its git worktree survive switching from Claude Code to Codex, OpenCode, or another agent; parallel tasks run in isolated worktrees and the same host is reachable from desktop, web, and mobile.
• muxel - GPU-accelerated native desktop multiplexer (not a TUI) where every pane embeds a real terminal running a coding agent, with first-class git worktrees, live agent status, scheduled runs, and notifications.
• nimbalyst - Visual workspace pairing parallel worktree sessions with kanban and direct visual editing. Claude Code, Codex, OpenCode.
• Nuphos - Desktop and web workspace where a team runs Claude Code and Codex via ACP adapters across people and machines, with sessions that outlive any single laptop.
• octomux - Local dashboard with a kanban fleet view, one unified permission inbox across agents, and in-app diff review.
• omg.dev - Open-source parallel-agent harness: run coding agents on your own computer or a hosted one, controlled from a single web UI with a mobile client. Claude Code, Codex, Grok, Cursor, OpenCode, Copilot, Pi.
• OpenChamber - Open-source workspace for running, supervising, and reviewing AI coding work across desktop, browser, editor, and mobile, with parallel model runs and per-run worktrees.
• Open Session - Self-hosted server driving coding sessions in git worktrees on your own box or in isolated sandboxes, with a web UI, Slack/Linear/Plain/GitHub intake, diff and PR review, and multiple Codex and Claude subscriptions.
• Orca - Agentic development environment for running a fleet on your own subscription, available on desktop and mobile.
• Paseo - Self-hosted daemon running agents in parallel on your own machines, driven from desktop, iOS/Android, web, or CLI, with voice control, diff review, and no telemetry or forced log-ins. Claude Code, Codex, Copilot, OpenCode, Pi.
• Ouijit - Kanban board and terminals wired together by lifecycle hooks, scripts, and a session-aware CLI, so a task runs by hand, on a script, or delegated to the agent. Per-task worktrees, optional VM sandboxing. Claude Code, Codex, Pi, OpenCode.
• parallel-code - Desktop app running Claude Code, Codex, and Gemini CLI side by side in isolated worktrees, with a built-in diff viewer and one-click merge.
• Podium ADE - Open-source workspace for taking ideas from conversation to coordinated work with coding agents. A shared task system lets them organize the effort while developers follow progress and change direction.
• Pragma - Native desktop app running agent teams in parallel worktrees, each with its own branch and GPU-accelerated terminals, with a task board from prompt to PR, fan-out races that compare agents on one prompt, and a public plugin API. Desktop, web, and mobile, locally, over SSH, or in WSL. Claude Code, Codex, OpenCode, Cursor.
• Proliferate - Agent IDE that runs sessions locally or in the cloud and lets you build reusable workflows from them.
• qm - Multiplayer harness where each teammate gets an isolated workspace to run agents independently, driven from Slack or the web.
• Reemoat - Self-hosted remote control for any coding agent: run coding agents on your own machines and supervise them from anywhere, end-to-end encrypted.
• Roamgate - Browser and PWA client for Herdr that controls parallel terminals, monitors coding agents, and reviews files and diffs from desktop or mobile. Requires a running Herdr server. Codex, Claude Code, Kimi, Grok Build, Pi, and more.
• Runner - Native macOS and Windows app running CLI agents side by side in split panes, each keeping its own TUI in a real terminal, and putting them on one mission as a crew with a lead. Claude Code, Codex, Copilot CLI, pi.
• supacode - Native macOS command center for worktree-per-agent development.
• Superagent - macOS desktop app giving Claude Code and Codex a real browser to drive, an iOS Simulator to install and screenshot apps in, and a phone companion app for remote monitoring.
• superset - Code editor built around running many agents on your machine at once.
• synara - GUI desktop workspace for running and managing agents across local projects.
• t3code - Harness control surface available as web, mobile, and desktop app. Claude Code, Codex, Cursor, Grok Build, OpenCode.
• takopi - Telegram bridge that puts Codex, Claude Code, OpenCode, and Pi sessions in a chat thread.
• Tempest - Tauri desktop ADE running CLI agents in parallel isolated worktrees, with a shared local code-knowledge graph that cuts token use across sessions, plus live status and built-in diff/PR review.
• Threadlines - Desktop workspace where each thread can run in its own Git worktree beside a live browser, terminal, and source control, and a second agent can join a thread to answer questions or review the first one's changes. Claude Code, Codex, Cursor, fx.
• tlbx - Self-hosted browser workspace holding persistent real PTY sessions on your own machines, reachable from any browser or phone.
• Tortie - Native macOS agent multiplexer with familiar IDE features: all projects in one window, agents that survive restarts, and organized terminal sessions without tmux.
• Traycer - Bring-your-own-agent workspace running many sessions in parallel with context shared across models and providers, plus agent-to-agent messaging, shareable boards, and cross-device sync.
• vibe-tree - One git worktree per agent, delivered as desktop, web, and CLI.
• vibecraft - RTS-style workspace for commanding coding agents.
• Vicoa - Agentic IDE and AI orchestrator for running a team of coding agents from desktop, web, or mobile, with real-time sync, parallel git worktrees, and push notifications. Claude Code, Codex, OpenCode, Gemini, Cursor, GitHub Copilot, Kimi, Hermes.
• Waku - Native macOS desktop app for working with local coding agents, keeping projects, sessions, and transcripts on your machine. Supports Amp, Claude Code, Codex CLI, Cursor CLI, Grok Build, OpenCode, and Pi.
• wmux - Terminal workspace app for macOS and Windows that runs the real agent CLIs in parallel, with git worktree fan-out, agent-to-agent messaging, a fleet board, and a phone companion. Supports Claude Code, Codex, Gemini CLI, and OpenCode.
• xum - Desktop app for isolated, parallel agentic development.
• Yardsort - Cross-platform Tauri desktop app giving each task its own git worktree and real terminal, with live per-file diffs, agent hand-offs, YAML workflows, and terminals that keep running after the window closes.
• Zaivern Code - Cross-platform Rust desktop cockpit for running Claude Code, Codex, Gemini CLI, and 30+ coding agents in parallel, with fleet monitoring, mobile control, and line-level ownership to prevent merge conflicts.
• Zeron - Cross-device control plane for coding agents, syncing sessions across machines and keeping agents running on an always-on daemon. Claude Code, Codex, Cursor, Grok, Hermes, Pi.
• zuse - Chat-first desktop app wrapping Claude Code, Codex, Grok, Gemini, Cursor, and OpenCode in persistent sessions. macOS and Linux.

Systems where multiple specialized agents actively coordinate, communicate, and delegate toward a shared goal.

• 5dive - Named agents on a shared org chart and backlog hand work to each other and escalate to a human over Telegram. Claude Code, Codex, Grok, Antigravity, OpenCode.
• Agent Teams - Desktop app where you give high-level commands to autonomous coding-agent teams across Claude Code, Codex, OpenCode, Cursor, Grok, GitHub Copilot, Kiro, Z.AI, MiniMax, Kimi, 200+ models, and 75+ LLM providers. Agents coordinate through inter-agent messaging, Kanban tasks, and built-in code review.
• agent-kanban - Leader-worker task board with cryptographic agent identity. Claude Code, Codex, Gemini CLI.
• agent-swarm - Self-hosted AI company operating system where a lead agent delegates goals to workers in isolated containers, with persistent memory, schedules, and review gates. Claude Code, Codex, pi, OpenCode, Cursor, Amp, Grok, Devin, and ACP agents.
• AgentBridge - Local MIT CLI that keeps Claude Code and Codex as live peers in one session for mid-turn review, task split, and quota-boundary handoff.
• agentsmesh - Remote AI workstations with PTY sandboxes and worktree isolation, coordinating across channels and pod bindings. Claude Code, Codex, Gemini CLI, Aider, OpenCode.
• Agon - Orchestrates scientist, coder, and auditor loops from research topic through proposal to experiment.
• Alook - Shared rooms where people and agents collaborate: local coding agents get persistent identities with handles, inboxes, and memberships, while agents keep running on your own machine.
• buzz - Agents are first-class members of shared channels on a Nostr relay you own, with their own keys and audit trails. Claude Code, Codex, Goose.
• claude_codex_bridge - Workspace for mixing different vendors' CLI agents in one visible collaboration session.
• ClawTeam - Agents spawn and manage their own teammates from one command, coordinating through file-based or P2P inboxes across tmux worktrees.
• CompanyHelm - Distributed orchestrator with task management and direct agent-to-agent conversations.
• corellis - Multi-agent governance framework for OpenClaw — goal decomposition, fleet-wide memory, correction propagation, and approval workflows for 20+ agent fleets.
• crewAI - Framework for orchestrating role-playing, autonomous AI agents that collaborate through defined roles, tools, and task delegation.
• Crewly - Runs teams of role-based coding agents with task delegation, shared memory and a live web dashboard. Claude Code, Codex, Gemini CLI, OpenCode.
• Fusion - Multi-node orchestrator with a kanban board, plan-review-execute gates, per-task worktrees, and hierarchical missions.
• gastown - Scales to 20-30 agents with a coordinator, git-backed issue tracking, health watchdogs, and a Bors-style merge queue.
• hcom - Lets agents message, watch, and spawn each other across terminals. Claude Code, Codex, Antigravity, Cursor, OpenCode, Kilo, and more.
• kodo - Directs agents through work cycles where a separate agent independently verifies each result. Claude Code, Codex, Gemini CLI.
• loki-mode - PRD-to-deployed-product SDLC with 41 agents in 8 swarms, nine quality gates, and blind three-reviewer code review. Source-available under BUSL-1.1.
• Markus - The all-in-one AI workforce platform for building AI agent teams: role-based agents that coordinate, delegate tasks, and work toward a shared goal with persistent memory.
• multi-agent-shogun - Shogun to karo to ashigaru hierarchy running up to 10 agents over tmux with no coordination API cost.
• NXTG-Forge Orchestrator - Coordinates Claude Code, Codex, and Gemini CLI on one shared repo through a research-plan-delegate-adversarial-verify-deploy pipeline, with file locking, knowledge capture, and drift detection. Single Rust binary.
• OpenRig - YAML-defined agent team with a lead agent that runs Claude Code and Codex together as one persistent system in tmux. npm CLI.
• openswarm - Local mission-control center for launching, monitoring, approving, and coordinating multiple AI agents in parallel.
• orc - Lightweight framework that piggybacks your existing CLI setup for planning, task decomposition, worktrees, and review.
• ORCH - CLI runtime managing agents as typed teams with an explicit state machine and goals. Claude Code, Codex, Cursor.
• Orkas - A commander agent decomposes goals and dispatches specialists with isolated skills and memory. Claude Code, Codex, OpenCode, OpenClaw, Hermes.
• OtoDock - Self-hosted "company OS" where agents work in departments, delegate to each other, and keep working unwatched on your Anthropic/OpenAI subscriptions — company map, per-agent dashboards, artifacts, meetings, and terminals. Source-available under FSL-1.1.
• paperclip - Self-hosted platform where agents wake on heartbeats to claim tickets, governed by org charts, budgets, and approval gates.
• Raven - Host agent that plans a complex task as a DAG and coordinates dependencies and parallel execution across built-in research, coding, design, and on-call agents and third-party agents over ACP, CLI, or OpenAI-compatible APIs. Presets include Claude Code, Codex, OpenCode, OpenClaw, Hermes Agent, GitHub Copilot, Qwen Code, and Kimi Code.
• Rovai AI - Desktop and web workspace where persistent teams of Claude Code, Codex CLI, OpenCode, and Pi agents collaborate through shared conversations, task delegation, and collaborative memory.
• ruflo - Meta-harness for deploying coordinated swarms and conversational multi-agent workflows. Formerly claude-flow.
• scion - Orchestration testbed running agents in parallel isolated containers with dynamic coordination and normalized telemetry.
• shire - Persistent team workspaces with inter-agent mailboxes and a shared drive. Claude Code, OpenCode, Pi.
• squad - Human-led AI agent teams for any project built on GitHub Copilot: repo-native specialist agents, coordinator routing, and parallel work, with persistent memory across sessions.
• tutti - Config-driven workflows passing typed artifacts between agents, each in its own worktree.

The "keep running until done" pattern — a single goal driven through a retry-until-verified loop.

• bernstein - Keeps no model in the coordination loop, so orchestration costs zero tokens. Verifies with tests and auto-commits across 40+ CLI agents.
• Dex - Human-gated planning, multi-reviewer code review, and dead-end-aware research loops, shipped as cross-platform binaries for 7 CLI backends.
• fractal - Loops that recursively delegate separable subtasks to child agents, bounded by configurable depth, cost, and time limits.
• future-os - One agent everywhere (terminal, desktop, mobile, CLI, IM bots) with a built-in loop control plane: durable goals, event-sourced state, and verification gates for 24h+ runs.
• LongHorizon-Harness - Long-running computer-use harness with fresh-context execution, independent auditing, and verified checkpoints across desktop apps and CLI workflows. Claude Code, Codex, OpenCode, DeepSeek Harness.
• Loop Engineering - Designs repeatable coding-agent loops around automation, worktrees, skills, state, and verification, with starters and a Loop Ready score for Grok, Claude Code, Codex, and OpenCode.
• LoopTroop - An LLM council plans the work, then Ralph-style loops retry failed units with fresh context. Executes via OpenCode worktrees.
• MartinLoop - Caps spend, enforces policy, verifies output, and rolls back failures, leaving inspectable run receipts.
• ordewell - Turns one goal into an editable plan of tasks, each carrying its own runner, model and mode, then runs each task as its own agent session and passes it only when evidence of completion shows up in that session's output. Claude Code, Codex, OpenCode.
• ralph-claude-code - Development loop for Claude Code with exit detection that recognizes when the work is actually finished.
• ralph-orchestrator - Hat-based orchestration that keeps agents looping until done, as a fuller implementation of the Ralph Wiggum technique.
• ralph-tui - Drives an agent through a task list autonomously, with a TUI for watching the loop.
• ralphex - Executes an implementation plan autonomously with a fresh session per task, plus validation, retries, multi-phase review, and automatic commits. Claude Code, Codex.
• toryo - Trust-based delegation with quality ratcheting that commits improvements and reverts regressions. Chains Claude Code, Aider, Gemini CLI, Ollama.

Unattended agents driven by an external source — an issue queue, a work board, or a schedule — that run and sync state back without side-by-side supervision.

• aeon - Runs unattended on GitHub Actions; dispatches skills to six coding-agent harnesses behind one contract (Claude Code, Grok, Codex, Pi, Vibe, Kimi), with quality scoring, git-persisted memory, a self-healing loop, and reactive triggers.
• agent-qa - Runs natural-language web and mobile test suites through a self-healing execution loop, persists memory between runs, and exposes a dashboard, CLI, MCP server, and coding-agent skills.
• background-agents - Sessions trigger from a web UI, Slack, GitHub, Linear, webhooks, or cron, run in Modal, Daytona, Vercel, E2B, or OpenComputer sandboxes, and open attributed PRs.
• centaur - Multiplayer self-hosted agents with Slack-native conversations, Kubernetes sandboxes, shared tools, and durable workflows.
• claude-code-action - Anthropic's official GitHub Action, detecting from context whether to answer, review, or implement. Auth via Anthropic API, Bedrock, Vertex, or Foundry.
• codex-action - OpenAI's official GitHub Action, running Codex CLI headlessly under drop-sudo, unprivileged-user, or fully read-only sandboxes.
• Contrabass - Terminal-first orchestrator for issue-driven agent runs, pulling work from Linear, GitHub Issues, or a local board into git worktrees with TUI, headless, and dashboard modes.
• cyrus - Watches Linear, GitHub, GitLab, and Slack issues assigned to it, spinning up an isolated worktree per issue. Claude Code, Codex, Cursor, Gemini.
• Frink - Desktop app that starts a Flow from a ticket (Linear, Jira, Shortcut, ClickUp), an alert or event (Sentry, PostHog, Vercel, Cloudflare, Supabase, and more), any webhook, or a schedule, then runs it as a graph of agent, shell, condition, and approval steps in its own worktree and parks blocked agents in a Work Queue. Claude Code, Codex.
• gh-aw - Compiles agentic workflows written in Markdown into GitHub Actions YAML. Read-only by default, with writes only through sanitized safe-outputs. Copilot, Claude, Codex, Gemini.
• lalph - Orchestrator driven by whichever source of issues you point it at.
• Machinist - Keeps coding agents working on a repository without making a human orchestrate every step from a terminal, pulling tasks from trusted ticket queues into isolated Codex workspaces.
• multica - Managed agents platform where you assign tasks, track progress, and let agents compound skills between runs.
• NEEDLE - Runs unattended against a shared bead queue (SQLite, atomic claims), dispatching each bead to a headless CLI — Claude Code, Codex, OpenCode, Aider — with every outcome routed through an explicit state machine; no inter-agent channel, coordination is done at decomposition time.
• no_human - Takes a ticket (Jira, Linear, monday.com, GitHub/GitLab issues) to a reviewed pull request on your own machine: a second model in a fresh session reviews each diff and is told to refute "done", a tamper guard blocks net test reductions before that review, and merging stays human. Claude Code as the coder; Codex and local backends optional. MIT.
• open-swe - Invoked from Slack, Linear, or GitHub comments; each task runs in its own cloud sandbox and ends in a draft PR linked to the ticket.
• OpenHands - Self-hostable control center running its own agent or driving Claude Code, Codex, and any Agent Client Protocol agent, on schedules or webhooks.
• Orbi - Picks up GitHub Issues labeled ai-ready, implements each in an isolated worktree, has a separate session review the PR against the Issue's acceptance criteria, then merges only the reviewed head and cuts a tagged release. Runs on Pi with any OpenAI-compatible API or a Codex subscription.
• remote-swe-agents - Serverless control plane on Lambda with a dedicated EC2 worker per session, triggered by issue comments, assignments, and PR reviews.
• run-gemini-cli - Google's official GitHub Action, running on event or schedule triggers or on demand via @gemini-cli /review and /triage.
• sortie - Turns tracker tickets into agent sessions. Agent-agnostic and tracker-agnostic, as a single Go binary with SQLite persistence.
• SuperPlane - Coordinates coding agents, source control, CI, review, approvals and feedback to turn routine backlog issues into review-ready pull requests. Supports Claude, Cursor and OpenAI.
• symphony - Turns project work into isolated autonomous runs, so teams manage the work rather than supervise the agent.
• Tale - Runs project-board tasks in persistent sandboxes, with manager-agent delegation and deliverable review. Supports Claude Code, Codex, OpenCode, and other configured runtimes.
• Taskuary - Local-first work inbox that triages email, chat, issue trackers, and scheduled reports into supervised Claude Code, Codex, Gemini, Cursor, or Copilot CLI runs, with conflict-aware queuing, live terminals, and approval-gated replies.

Control planes, coordination protocols, harness adapters, and runtimes — the layer beneath your agents rather than the surface you work in.

• Agent Barn - Open-source (Apache-2.0) control plane for AI agents: teams talk to agents in Slack, Teams, Telegram, Discord or email, agents work across Jira, GitHub, Confluence and more, and every conversation, tool call, log and cost is recorded. Runs agent runtimes like Hermes and OpenClaw on your own Kubernetes cluster, deployed with Helm.
• Agent Messaging Protocol - Open standard for agent-to-agent messaging with Ed25519-signed envelopes, federation across providers, and delivery that must be proven rather than assumed. Reference server, TypeScript SDK, and a Claude Code plugin.
• agent-runbook - Compiles YAML runbooks with loops, branching, and parallelism into SKILL.md files for Claude Code and Codex.
• Agentlas OS - Keeps specialist agents in a hub and spins up a temporary orchestrator per task, with A2A routing and governed memory gates. Formerly Hephaestus.
• agenttier - Kubernetes runtime giving each agent its own Pod and PVC sandbox behind a default-deny NetworkPolicy, with a streaming SSE invoke API.
• aGiTrack - Takes what a coding agent produces and commits each turn to git, recording the prompt, model, and that turn's token cost in the commit message, with the agent confined to its own worktree. Claude Code, Codex, and OpenCode.
• AIWG - Deploys versioned agents, skills, rules, and governed workflows into the native project paths used by Claude Code, Codex, Copilot, Cursor, and other coding agents.
• Archon - Harness builder for deterministic AI coding workflows, combining agent steps with scripts, validation gates, approvals, and isolated git worktrees. Claude Code, Codex, and more.
• AX - Google's declarative runtime for running autonomous agent workloads at cluster scale: Kubernetes-style task specs, sandboxed workspaces, and network fencing.
• Claudexor - Routes one coding thread across harnesses with quota-aware rotation between subscription profiles, Best-of-N runs, and cross-family review.
• codecast - Watches your real local sessions and surfaces them in a live triage inbox, keeping a searchable record with line-level agent attribution. Claude Code, Codex, Cursor, Gemini.
• Concord MCP - Shared coordination protocol for Claude Code, Codex, Cursor, Gemini CLI, and Grok Build agents to claim work, detect edit collisions, exchange durable messages, transfer ownership, and hand off review evidence without replacing their existing harnesses.
• Cotal - Open pub/sub standard over NATS JetStream where mixed coding agents share a space with presence, channels, durable direct messages, and role-addressed anycast, in any topology you wire. Claude Code, Codex, OpenCode, Hermes, Jcode, and pi.
• Crewplane - CLI-first control plane that turns one-off coding-agent calls into reviewable Markdown workflows spanning Claude Code, Codex, Gemini CLI, or Copilot CLI. Explicit artifact handoffs keep execution inspectable on disk, while validated completed nodes let failed workflows resume instead of starting over.
• foremerge - Coordination protocol above Git: agents declare intent, semantic scope, and operation before writing code, deterministic rules raise findings when plans collide, and acceptance is gated on a verification run it executes itself. One Rust binary over local SQLite, with MCP for Claude Code, Codex, and Cursor.
• guild - Shared context, memory, and task coordination as a single Go binary over local SQLite with hybrid keyword and semantic search.
• handoff - Delegates a task to DeepSeek, Codex, or Claude from inside your current Claude Code or Codex session, returning the result automatically.
• Heym - Self-hosted runtime for tool-using LLM agents and OpenCode workflows, with sub-agent orchestration, MCP integration, approval checkpoints, and execution traces.
• LionClaw - Local control plane running coding agents as durable, auditable workers with explicit state, skills, and checkpoints.
• Mnemoverse - Hosted memory engine over MCP: decisions, preferences, and lessons follow an agent between sessions and tools, and recall re-ranks from reported outcomes rather than similarity alone. Remote endpoint with sign-in, or npx -y @mnemoverse/mcp-memory-server@latest with an API key. Claude Code, Cursor, Gemini CLI, VS Code, Windsurf, ChatGPT. MIT server, free tier.
• NemoClaw - Runs Hermes, LangChain Deep Agents, and OpenClaw inside NVIDIA OpenShell with managed inference.
• neuralyzer - Lets an agent wipe its own session context and re-run the first message, making Ralph loops easier to engineer.
• oh-my-codex - Workflow layer for OpenAI Codex CLI: stronger default sessions, reusable skills, native hooks, HUD/status surfaces, project guidance, and team-style execution commands.
• omnigent - Meta-harness running Claude Code, Codex, Cursor, OpenCode, Hermes, Pi, or custom YAML agents against swappable sandbox backends, with policy enforcement.
• Open Multi-Agent - TypeScript-native runtime where a coordinator turns a goal into a task DAG and a deterministic scheduler runs specialized agents, with approvals, traces, evaluation, checkpoints, and resume support.
• openfang - Open-source agent operating system.
• OrcaReplay - Records a coding agent at the process and socket boundary so model traffic, shell exit codes, per-turn file changes and MCP JSON-RPC share one timeline, then replays the run offline with the network off or forks it from a checkpoint onto a different model.
• ox - The team hivemind: persistent context recorded once and recalled across agents, machines, and teammates, as a Go CLI.
• sandbox-agent - Daemon, HTTP/SSE API, and TypeScript SDK for driving six coding agents inside E2B, Daytona, Modal, Cloudflare Containers, or Docker.
• skillfold - Declares skills in YAML and pins exact revisions in a lockfile so installs are reproducible across Claude Code and Codex.
• sub-agents-skills - Portable Markdown definitions that route a task to a chosen backend, model, effort level, and permission set.

Always-on agents you reach over chat or a desktop app. They remember across sessions, run on their own schedule, and hand work off to tools and other agents — coding agents included, though the work isn't limited to code.

• assistant - Panel-based assistant whose plugins share one workspace of notes, lists, and objects.
• automata - Matrix-native workspace where Temporal-backed durable workflows survive restarts and keep long tasks moving.
• Cloudflare OS - Self-hostable "company OS" on Cloudflare Workers: a chat UI where agents preloaded with your company context do tasks, build sandboxed apps, and stay inside a Gatekeepers guardrail framework.
• Comma - Sessionless personal agent that breaks goals into tasks and keeps working through agentic loops across your computer, phone, and browser, with computer use, files, and remote control; self-hostable (AGPL-3.0).
• Coworker - Open source AI coworker that lives on your desktop. Formerly accomplish.
• denchclaw - Managed OpenClaw framework aimed at CRM, sales automation, and outreach.
• ghostclaw - An AI that lives on your computer and does things for you.
• Grux - Native macOS agent that runs agent swarms in parallel, opens terminal sessions it can undo, and reaches your mail, calendar and meetings; runs on a local Ollama model or your own Anthropic key, and any coding agent can drive it over MCP or its CLI.
• hermes-agent - Self-improving harness with persistent cross-session memory and auto-generated skill documents.
• Hivekeep - Self-hosted team of specialized agents with persistent memory that delegate and build their own tools and mini-apps. Telegram, Slack, Discord, Matrix. Single container, MIT.
• ironclaw - Agent OS in Rust focused on privacy, security, and extensibility.
• iva - Telegram assistant that turns your messages, voice notes and photos into an Obsidian-compatible markdown vault it remembers across sessions. Crons, skills, MCP and Google Workspace from an in-chat menu. Self-hosted in one command, MIT.
• jelly - Local-first multi-bot system for running your operation from one VM: persistent agents grouped into project directories, phone-friendly web UI via Tailscale, browser control, and sudo on request.
• lemon - Local-first assistant and coding agent runtime.
• leon - Long-running open-source personal assistant with voice and text interfaces.
• lobsterai - Desktop-grade agent for data analysis, slides, docs, and web research.
• lorca - E2E-encrypted personal agent chat: create bots, talk 1:1 or in group chats, and let them hand work to each other. Rust CLI, native macOS client, and phone apps.
• lucinate - Terminal-native chat client for OpenClaw, Hermes, Ollama, and OpenAI-compatible providers, with cron management and session browsing.
• MetaClaw - Assistant that learns and evolves from conversation alone.
• nanobot - Ultra-lightweight self-hosted assistant in Python with WebUI, tools, memory, MCP, and multi-agent workflows.
• nanoclaw - Lightweight OpenClaw alternative running in containers, connecting to WhatsApp, Telegram, Slack, Discord, and Gmail.
• nullclaw - Fully autonomous assistant infrastructure written in Zig.
• Octop - Self-hosted multi-user assistant with a built-in expert team operating in parallel, reachable from web, Telegram, Feishu, DingTalk, QQ, and WeCom.
• openclaw - Your own personal AI assistant, on any OS and any platform.
• OpenHuman - Open-source personal agent harness: desktop app and Rust library with built-in memory, token compression, and instant tool search, efficient enough to run hundreds of agents on a $10 server.
• OpenInstinct - iMessage assistant that drives a real browser to do chores, book tickets, and handle groceries, keeping your passwords and cards in an encrypted vault it unlocks per action. Self-hosted on your own Vercel, any model.
• OpenMausBot - Open-source Grok Bot-style team of bots in a chat-app sidebar, where every bot is a real local agent — Claude or Codex — with its own personality, model, cloud computer, and connected apps, behind approval gates. Local-first, bring-your-own-agent.
• OpenWorker - Open-source desktop AI coworker that delivers finished work — security review with re-scanned fixes, cloud posture audits, triaged inboxes — from specialist coworkers, with every action governed and logged. BYO model key or fully local via Ollama.
• Ouroboros - General-purpose agent with durable identity and memory, reviewed self-modification, multi-agent coordination, and desktop and headless interfaces.
• Overlay - Open-source workspace where humans and agents share context — knowledge, files, memory, connected apps — so you delegate repeatable work to agents, review what they produce, and take action through tools, provider-neutral.
• PersonalJarvis - Desktop voice and chat assistant for Windows, macOS, and Linux that runs CLI coding agents such as Claude Code, Codex, and Gemini CLI side by side in Git worktrees, with memory, scheduled routines, and any single model key or local models via Ollama.
• picoclaw - Tiny and fast assistant deployable anywhere.
• QwenPaw - Personal assistant that deploys to your own machine or the cloud and plugs into multiple chat apps. Formerly CoPaw.
• Rakazo - Self-hosted platform for persistent AI teammates with their own conversations, memory, and routines, running on shared team computers or isolated private ones, reachable from web, desktop, and mobile with voice mode. Bots delegate to peer bots or short-lived subagents. BYO model and sandbox.
• rho - Stays running, remembers across sessions, and checks in on its own. macOS, Linux, Android.
• row-bot - Local-first desktop assistant that reasons through messy context, orchestrates tools and providers, and works inside your files, repos, and channels — durable memory, scheduled tasks, voice, visible browser automation, and parent-led child agents for research, review, and implementation. Runs on Ollama or opt-in cloud models. Formerly Thoth.
• rowboat - Open-source AI coworker with memory.
• Talorys - Personal AI assistant that runs entirely in your own Cloudflare account: chat, durable memory, tasks, notes, and scheduled routines, deployed with one command; single-user and free-tier friendly.
• taOS - Self-hosted AI agent OS where memory, conversations, agents, and files live on hardware you own, offline by default with cloud by choice, including multi-framework group chat and a desktop GUI.
• Xiryn - Open-source personal agent on your own machine: each agent gets its own Linux desktop in Docker, with an encrypted vault, any model under your keys, and Telegram control.
• zclaw - Complete personal assistant in 888 KiB, running on an ESP32 with GPIO, cron, and custom tools.
• zeroclaw - Fast, small, fully autonomous assistant infrastructure in Rust, deployable anywhere.

A watchlist of projects without a push in the last few months (checked 2026-07-28). They stay here until they're active again, then move back up.

• 1code - Orchestration layer for Claude Code and Codex. (last commit 2026-03; archived)
• antfarm - Build your agent team in OpenClaw with one command. (last commit 2026-02)
• babyagi3 - A minimal AI agent you configure once, then run through natural language. (last commit 2026-03)
• cashclaw - An autonomous agent that takes work, does work, gets paid, and gets better at it. (last commit 2026-03)
• clawe - Multi-agent coordination system: think Trello for OpenClaw agents. (last commit 2026-02)
• CodexMonitor - Orchestrate multiple Codex agents across local workspaces. (last commit 2026-03)
• gnap - Git-native agent protocol coordinating agents through a shared repo as a task board, with no orchestrator process. (last commit 2026-03)
• lettabot - Personal assistant that remembers everything. (last commit 2026-05; archived, replaced by Letta Code)
• mercury - Personal AI assistant that lives where you chat. (last commit 2026-03; archived)
• opengoat - Build organizations of OpenClaw agents coordinating across Codex, Claude Code, Cursor, and OpenCode. (last commit 2026-04)
• ralphy - Bash script that loops Claude Code, Codex, OpenCode, Cursor, Qwen, or Droid until the task is done. (last commit 2026-02)
• subtask - Claude Skill that runs your tasks through subagents in git worktrees. (last commit 2026-04)
• swarm-protocol - Headless coordination over MCP: claim work, detect file conflicts, heartbeat, and hand off across sessions. (last commit 2026-03)
• vibe-kanban - Kanban board for managing AI coding agents. (last commit 2026-04)
• wit - Locks individual functions rather than files via Tree-sitter, warning agents of conflicts before they write. (last commit 2026-03)
• wreckit - Run the Ralph Wiggum loop over your roadmap. (last commit 2026-04)