🛠️ Awesome ADE

A curated list of open-source Agentic Development Environments — the tools that make AI agents first-class citizens of your development workflow.

An ADE is the evolution of the IDE. An IDE assumes a human types and the machine completes. An ADE assumes an agent plans, edits files, runs terminal commands, manages git branches and fixes failing tests — while the human steers, reviews and merges.

That inversion changes which questions matter. Instead of "how do I edit text faster", an ADE is designed around:

• How many agents run at once? One session, or a dozen in parallel?
• Where do they run? Local worktree, tmux pane, container, VM, or the cloud?
• How are they isolated? Can agent A break what agent B is building?
• How do I review? Diffs, PRs, CI checks, human-in-the-loop gates.
• How do I steer from anywhere? Terminal, desktop app, browser, phone.

This list is organised the way you actually pick these tools: by packaging (TUI, tmux, desktop, web, mobile), then by the layer of the stack they occupy. Every entry is open source, actively maintained and hosted on GitHub. See CONTRIBUTING.md.

Maintained by KyroLabs. See also: Awesome Agents · Awesome LangChain.

Contents

• Anatomy of an ADE
• Orchestrators — Terminal & TUI
• Orchestrators — tmux-native
• Orchestrators — Desktop
• Orchestrators — Web & Self-hosted
• Remote & Mobile Control
• Coding Agents (the engines)
• Harnesses & Agent SDKs
• Editor-native Agents
• Autonomous & CI Runners
• Isolation & Sandboxing
• Spec, Planning & Task Layers
• Context, Skills & Routing
• Observability & Cost
• Review & Quality Gates
• Protocols & Standards
• Browser & Computer-use Runtimes
• Comparison Matrix
• Notable Proprietary ADEs
• Related Lists
• Contributing

Anatomy of an ADE

Most tools in this list sit on exactly one of five layers. Knowing which layer you are missing is usually the fastest way to pick your next tool.

Packaging legend used below: ⌨️ TUI · 🪟 tmux · 🖥️ Desktop · 🌐 Web · 📱 Mobile · 🧩 Editor extension · 🌲 git worktree isolation · 📦 container/VM sandbox

Orchestrators — Terminal & TUI

Keyboard-driven mission control. You stay in the terminal; the tool handles session lifecycle, worktrees and switching between agents.

• herdr: Agent-aware multiplexer and runtime your coding agents live on — persistent workspaces, session recovery, and a fast TUI across agents.
• Claude Squad: Terminal app managing multiple agents in isolated workspaces — detached background sessions backed by tmux and persistent git worktrees. Supports Claude Code, Codex, Aider, Gemini, OpenCode and Amp.
• ralph-tui: Drives an agent through a task list autonomously with an exit-detection loop, so long-running work does not need babysitting.
• ccmanager: Coding-agent session manager across git worktrees and projects — carries conversation history and project state into new worktrees. Works with Claude Code, Gemini CLI, Codex CLI, Cursor Agent, Copilot CLI, Cline CLI, OpenCode and Kimi CLI.
• agent-deck: One TUI over every session — groups, search, forking, git worktrees, cost tracking and a phone-controlled conductor for the whole fleet.
• ccswarm: Multi-agent orchestration with git worktree isolation and specialised roles for collaborative development.

Orchestrators — tmux-native

tmux turns out to be an excellent agent substrate: sessions survive disconnects, panes are cheap, and everything is scriptable over SSH. These tools lean into it rather than reinventing it.

• CLI Agent Orchestrator: AWS Labs multi-agent orchestration for coding CLIs — Claude Code, Kiro, Codex and more, each coordinated inside isolated tmux sessions.
• dmux: Dev agent multiplexer pairing coding agents with git worktrees over tmux, one pane per task.
• amux: Single-file, tmux-native control plane — run, monitor and orchestrate dozens of parallel Claude Code, Codex and Gemini sessions from one web dashboard or your phone, with self-healing sessions.

Orchestrators — Desktop

Native and Electron/Tauri apps. Better for diff review, multi-pane layouts and anything you want visible on a second monitor.

• Orca: Fan one prompt across several agents, each in its own git worktree, then compare and merge the winner. Ghostty-class terminals with infinite splits, SSH worktrees onto a remote box, native GitHub and Linear browsing, line-level annotation of AI diffs, a design mode that pipes a clicked DOM element into the prompt, and an orca CLI so agents can drive the workspace themselves. Desktop, mobile companion and VPS.
• Emdash: Open-source ADE for running multiple coding agents in parallel, each task in its own git worktree. Local-first SQLite state, SSH to remote machines, and Linear/GitHub/Jira/GitLab ticket ingestion with PR creation and CI review built in.
• Aperant (formerly Auto Claude): Describe a goal and agents plan, implement and validate it — up to 12 agent terminals in parallel, all changes in git worktrees, a self-validating QA loop before you review, AI-assisted merge-conflict resolution, a memory layer across sessions, and GitHub/GitLab/Linear task import behind a Kanban board. Three-layer security model (OS sandbox, filesystem restriction, dynamic command allowlist). Windows, macOS and Linux. Note: 2.x is in maintenance mode and code PRs are paused while 3.0 is rebuilt.
• superset: Code editor built around running many agents at once rather than around a single cursor.
• Paseo: A local daemon manages the agents; desktop, mobile, web and CLI clients all attach to it. One interface over Claude Code, Codex, Copilot, OpenCode and Pi, running on your own machine with your own dev environment. Voice mode, and no telemetry, tracking or forced log-in.
• CodeLayer (HumanLayer): Human-in-the-loop control plane for coding agents — approvals, interventions and durable session state so autonomous runs stay reviewable.
• CodexMonitor: Native macOS app to orchestrate and monitor multiple Codex agents locally.
• AutoMaker: Kanban board that turns product tickets into working code, each card implemented by an agent in its own worktree.
• Crystal: Desktop app running parallel Claude Code sessions in isolated git worktrees, with side-by-side diff review before merge.
• mux: Coder's desktop app for isolated parallel agentic development.
• Nimbalyst: Visual workspace where you and the agent collaborate in WYSIWYG editors — markdown, mockups with annotations, Mermaid, Excalidraw, CSV, data models and Monaco — reviewing the agent's changes as red/green diffs. Parallel sessions on a kanban, sessions linked to the files they touched, worktrees, and a mobile companion.
• parallel-code: Desktop app for running Claude Code, Codex CLI and Gemini CLI side by side, with a built-in diff viewer and merge flow.
• Arbor: Fully native desktop app built around git worktrees, terminals and diffs — the three things an agentic workflow actually touches, and nothing else.
• Dorothy: Desktop app orchestrating multiple AI CLI agents (Claude Code, Codex, Gemini) simultaneously with automations, Kanban management, remote control and MCP servers.
• Sculptor: Imbue's agent workspace running each session in a container so agents can execute freely without touching your machine.
• Termic: Spawns the real claude, codex, agy, copilot and grok binaries rather than vendor SDKs, so inference rides the Pro/Max plan you already pay for. One git worktree per agent, an optional per-workspace macOS sandbox cage, prompt broadcast to every agent at once, and a work-done indicator per pane.
• Tempest: Keeps a local code-knowledge graph shared across every parallel session, so five agents do not each re-read the codebase from scratch — the project reports up to 64% less context consumption and 58% fewer tool calls. Worktree and branch per agent, built-in diff and PR, and per-OS process isolation (Job Objects on Windows, Seatbelt on macOS, bubblewrap on Linux). Note that agents are spawned permission-skipping by default, toggleable in settings.

Orchestrators — Web & Self-hosted

Browser-based, which means team-shareable and reachable from any device without installing anything.

• Vibe Kanban: Kanban board for managing AI coding agents — queue tasks, review diffs, and switch between Claude Code, Codex, Gemini and others per card.
• gastown: Scales to 20–30 concurrent agents with a coordinator and a merge queue, aimed at swarm-sized workloads.
• OpenHands: Self-hostable platform for software development agents — the agent gets a browser, a terminal and an editor, and you watch it work in a web UI.
• Open SWE: LangChain's cloud-sandboxed asynchronous coding agent, invoked from Slack, Linear or GitHub and returning a PR.
• ruflo: Agent meta-harness for deploying coordinated multi-agent swarms and long-running autonomous workflows.

Remote & Mobile Control

The ADE stops being a place you sit and becomes a thing you check on. These bridge running sessions to your phone or a chat app.

• Happy: Mobile and web client for Claude Code with end-to-end encryption — start a session at your desk, keep steering it from your phone.
• VibeTunnel: Turns any terminal session into a browser-accessible one, so agents running on your Mac are controllable from anywhere.
• Omnara: Command centre for agents across web, mobile and terminal, with live notifications and permission prompts routed to you.
• takopi: Telegram bridge that puts an agent session in a chat thread.
• ClaudeClaw: Persistent agent orchestrator as a Claude Code plugin — multi-channel routing (Slack, WhatsApp, Telegram), OS-level sandbox isolation, composable extensions, structured memory and webhook triggers.
• ADE: One workspace for Claude Code, Codex, Cursor, Factory Droid and OpenCode, with every chat and CLI session syncing in real time across macOS, Windows, iOS, web and terminal — start a thread on the desktop and finish it from another machine.

Coding Agents (the engines)

The harnesses that orchestrators drive. Pick the orchestrator for the workflow, the agent for the loop quality and provider support.

• OpenCode: The open-source coding agent — keyboard-driven TUI, build/plan agent modes, LSP integration for 20+ languages, MCP support, and 75+ providers plus local models via Ollama and LM Studio. Client-server architecture lets multiple frontends attach to one server.
• Gemini CLI: Google's open-source terminal agent with a large context window and built-in tooling.
• Codex CLI: OpenAI's local coding agent, with sandboxed execution modes and headless/CI operation.
• Aider: AI pair programming in your terminal, with repo-map context and automatic commits per change.
• Crush: Charm's glamourous terminal coding agent, multi-model with LSP and MCP support.
• Qwen Code: Alibaba's CLI agent tuned for the Qwen-Coder models, with agentic repo understanding and workflow automation.
• SWE-agent: The research harness that popularised issue-to-patch automation, with a configurable agent-computer interface.
• mini-SWE-agent: The same idea in ~100 lines of Python — the reference implementation to read before writing your own harness.

Harnesses & Agent SDKs

The loop underneath everything above: model calls, tool dispatch, permissions, session state. You reach for this layer when no existing ADE does what you want and you are building your own — a custom coding agent, an in-house review bot, an orchestrator with opinions.

Listed here because each one is a plausible foundation for an ADE. General-purpose agent frameworks aimed at things other than software development belong in Awesome Agents instead.

• Pi: Unified LLM API, agent loop, TUI and a coding CLI, built on a deliberately tiny system prompt with lazily-loaded skills. Usable as-is, but the design intent is that you fork and rewire it.
• Goose: Extensible on-machine agent that installs, executes and edits rather than only suggesting. MCP-native, ACP-compatible, and embeddable as a runtime rather than only a CLI.
• Agno: Full-stack framework for building, running and managing agent platforms, with memory, knowledge and a control plane included.
• LangGraph: Graph-structured agent runtime with durable execution, checkpointing and human-in-the-loop interrupts — the state machine most long-running agents eventually need.
• smolagents: Hugging Face's barebones library for agents that think in code — small enough to read end to end in an afternoon.
• OpenAI Agents SDK: Lightweight framework for multi-agent workflows with handoffs, guardrails and tracing. Also available for TypeScript.
• Mastra: Modern TypeScript framework for agents and AI applications — workflows, agent memory, tool calling, evals and a local dev playground in one package.
• Vercel AI SDK: The TypeScript toolkit most agent UIs are built on — provider-agnostic model calls, tool loops and streaming primitives.
• Pydantic AI: Type-safe agent framework built on Pydantic, with structured outputs and dependency injection for production pipelines.
• Microsoft Agent Framework: Successor to Semantic Kernel and AutoGen, for building, orchestrating and deploying agents and multi-agent workflows in .NET and Python.
• VoltAgent: TypeScript agent framework with built-in LLM observability, so traces and evals are not bolted on afterwards.
• Claude Agent SDK: Anthropic's SDK for building on the Claude Code harness — tool execution, sandboxing, hooks and stateful sessions. Also available for TypeScript.
• Strands Harness SDK: AWS's SDK for building an agent harness and controlling it end to end, rather than accepting a vendor's loop.
• Cloudflare Agents: Stateful agents on Durable Objects — hibernation between turns, WebSocket sessions and scheduled wake-ups at the edge.
• TrueForge: Owns the whole execution loop — model calls, MCP tools with OAuth, git-backed SKILL.md packs, sandboxed execution, tool approvals, subagents, deferred tool loading and compaction — exposed three ways: a chat UI, an HTTP API with a TypeScript SDK, and an embeddable UI SDK. SQLite in local mode, Postgres and Redis once a team shares it.

Editor-native Agents

For when the ADE is your editor rather than a separate app.

• Zed: High-performance multiplayer editor with a native agent panel, and the origin of the Agent Client Protocol — bring Claude Code, Gemini CLI or Goose into the editor over ACP.
• Cline: Open-source coding agent in VS Code with plan/act separation, terminal execution and full transparency over every model call.
• Continue: Build and share custom agents and rules across VS Code and JetBrains, with any model.
• Kilo Code: VS Code agent combining orchestration modes, memory-bank context and multi-provider routing.

Autonomous & CI Runners

The headless end of the spectrum: no human at the terminal, work triggered by an issue, a PR or a schedule.

• gh-aw: GitHub's agentic workflows — write the workflow in Markdown, compile it to a GitHub Actions run with a safe, permission-scoped agent.
• claude-code-action: Anthropic's official GitHub Action for running Claude Code on issues and pull requests.
• run-gemini-cli: Google's official Action for issue triage, PR review and on-demand agent runs.
• codex-action: OpenAI's official Action for running Codex headlessly in CI.
• Cyrus: Watches Linear, GitHub and GitLab for issues assigned to it and works them to a PR.
• remote-swe-agents: Serverless AWS control plane for long-running autonomous software agents.

Isolation & Sandboxing

The layer that makes parallelism safe. Worktrees isolate the filesystem; containers and microVMs isolate everything else.

• E2B: Secure isolated cloud runtimes purpose-built for executing LLM-generated code, with SDKs for spawning sandboxes per task.
• Daytona: Secure and elastic infrastructure for running AI-generated code, with sub-second sandbox creation and stateful workspaces.
• microsandbox: Self-hosted microVM sandboxes with hardware-level isolation and near-instant startup — the safety of a VM without the boot time.
• sandbox-runtime: Anthropic's OS-level sandboxing runtime for agents — filesystem and network restrictions applied to the agent's own process tree.
• container-use: Gives every agent its own containerised environment and git branch, so many agents work in parallel without conflicts and you can inspect any of them mid-run.
• Greywall: Deny-by-default command sandbox for coding agents — filesystem isolation, network control via a transparent proxy, built-in profiles for Claude Code and OpenCode, and a learning mode that generates configs.

Spec, Planning & Task Layers

Autonomy without a spec produces confident nonsense. These tools give the agent a plan to execute against and a place to record progress.

• Spec Kit: GitHub's toolkit for spec-driven development — specify, plan, break into tasks, then let the agent implement against an explicit contract.
• OpenSpec: Spec-driven workflow that gets agent and human aligned on the change before any code is written.
• BMAD-METHOD: Agile agent framework assigning planning, architecture and implementation to distinct specialised agent roles.
• Task Master: Turns a PRD into a dependency-aware task graph the agent works through one task at a time.
• Backlog.md: Git-native task manager — Markdown task files in the repo, with CLI, TUI and web board views that agents and humans share.
• Agent OS: Structured standards, specs and workflows so agents produce code that matches how your team actually builds.

Context, Skills & Routing

What the agent knows, what tools it can reach, and which model answers.

• MCP Servers: Reference and community servers for the Model Context Protocol — the standard way to hand agents tools and data sources.
• Serena: Semantic code toolkit exposed over MCP — gives agents symbol-level retrieval and editing instead of blind file reads.
• claude-code-router: Routes the Claude Code harness to arbitrary model backends, with per-task routing rules and cost control.
• claude-code-templates: Large library of ready-made agents, commands, hooks, MCP configs and settings, installable per project.
• AgentAPI: One HTTP API in front of Claude Code, Goose, Aider, Codex and Copilot — the integration seam for building your own ADE surface.

Observability & Cost

Parallel agents burn tokens in parallel. These tell you where they went.

• ccusage: Fast CLI for usage and cost analysis of Claude Code sessions, with daily, monthly and per-session breakdowns.
• Claude Code Usage Monitor: Live terminal dashboard with burn-rate tracking and predictions before you hit the limit.
• Manifest: Local-first cost observability for agents and harnesses — tokens, costs, messages and model usage across providers, with OTLP ingestion and self-hosting.

Review & Quality Gates

Agents generate more diff than a human can read. The bottleneck moves to review.

• PR-Agent: Automated PR description, review and code suggestions, runnable from CI or as a bot on every pull request.
• claude-code-security-review: Anthropic's security-focused review Action — reasons about the semantics of a diff rather than pattern-matching it, with false-positive filtering.

For human-in-the-loop approval gates inside the agent loop itself, see CodeLayer (HumanLayer) above.

Protocols & Standards

The plumbing that stops every ADE from writing bespoke glue for every agent.

• Agent Client Protocol (ACP): "LSP for coding agents" — a JSON-RPC standard letting any editor host any agent. Originated at Zed, with SDKs in TypeScript, Python, Rust, Kotlin and Java.
• Model Context Protocol: The specification for connecting agents to tools, resources and prompts.
• AGENTS.md: A simple open format for the README your agents read — adopted across most harnesses in this list.

Browser & Computer-use Runtimes

When the task leaves the repository: end-to-end testing, scraping, and driving real applications.

• Browser Use: Connects any LLM to a live scriptable browser for end-to-end web interaction and testing.
• Stagehand: Production-grade AI browser automation on top of Playwright, mixing deterministic code with natural-language actions.
• Steel Browser: Open-source browser infrastructure for agents — session-backed automation, extraction, screenshots and PDFs behind an AI-native CLI.
• Cua: Computer-use agent framework with high-performance macOS and Linux VMs for full-desktop automation.

Comparison Matrix

Orchestrators only — the tools you would actually choose between. "Isolation" is what keeps two parallel agents from colliding.

Notable Proprietary ADEs

Not eligible for this list — it is an open-source list — but they define the category and are worth knowing.

• Claude Code — Anthropic's terminal agent. Source-available CLI, and the harness most tools above orchestrate.
• Warp — Terminal-first ADE with an integrated autonomous agent that executes multi-step workflows across any repository.
• Cursor — The editor that made agent-first coding mainstream, with background agents and parallel worktree runs.
• Conductor — Polished commercial workspace for running many Claude Code agents in parallel with end-to-end task delegation.
• Agentastic — Native macOS multi-agent IDE covering 52 coding agents, with each agent in its own git worktree or container (Apple containers and Docker), plus editor, terminals, git, browser automation and agentic review. Free to use, closed development, extensibility said to be on the roadmap.
• Factory — "Droids" as delegated engineers, with a CLI and a browser control plane.
• Trae — ByteDance's agentic IDE showing live agent to-do lists, context panels and tool pipelines.
• Devin — Cognition's autonomous engineer with its own cloud workspace.
• Amp — Sourcegraph's agent, terminal and editor surfaces sharing one thread model.
• Kiro — AWS's spec-driven agentic IDE.
• Google Antigravity — Agent-first IDE built around a browser-and-editor agent manager.
• Jules — Google's asynchronous coding agent working from GitHub issues.

Related Lists

• Awesome Agents — open-source tools and products for building AI agents.
• Awesome LangChain — the LangChain ecosystem.
• Awesome Agent Orchestrators — exhaustive index of parallel-agent orchestrators.
• Awesome CLI Coding Agents — terminal-native agents and their harnesses.
• Awesome Claude Code — commands, files and workflows for Claude Code.

Contributing

Contributions welcome — read CONTRIBUTING.md first. In short: open source, on GitHub, in English, actively maintained, demonstrated traction, related to agentic development environments, and added at the bottom of the relevant section. Submit a PR, not an issue.

License

CC0 1.0 Universal — to the extent possible under law, KyroLabs has waived all copyright and related rights to this work.